a3s-boot 0.1.3

Adapter-first modular Rust web framework for A3S inspired by Nest.js
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
135
136
137

#![cfg(feature = "compression")]

use a3s_boot::{
    BootApplication, BootRequest, BootResponse, CompressionOptions, HttpMethod, RouteDefinition,
};
use flate2::read::GzDecoder;
use serde_json::json;
use std::io::Read;

#[tokio::test]
async fn compression_interceptor_gzips_accepted_responses() {
    let app = BootApplication::builder()
        .use_global_compression(CompressionOptions::new().with_min_size(1))
        .route(
            RouteDefinition::get("/hello", |_| async {
                Ok(BootResponse::text("hello hello hello hello"))
            })
            .unwrap(),
        )
        .build()
        .unwrap();

    let response = app
        .call(BootRequest::new(HttpMethod::Get, "/hello").with_header("accept-encoding", "gzip"))
        .await
        .unwrap();

    assert_eq!(response.header("content-encoding"), Some("gzip"));
    assert_eq!(response.header("vary"), Some("accept-encoding"));
    assert_eq!(
        decode_gzip(response.body()).unwrap(),
        "hello hello hello hello"
    );
}

#[tokio::test]
async fn compression_interceptor_skips_when_gzip_is_not_accepted() {
    let app = BootApplication::builder()
        .use_global_compression(CompressionOptions::new().with_min_size(1))
        .route(
            RouteDefinition::get("/hello", |_| async {
                Ok(BootResponse::text("hello hello hello hello"))
            })
            .unwrap(),
        )
        .build()
        .unwrap();

    let no_header = app
        .call(BootRequest::new(HttpMethod::Get, "/hello"))
        .await
        .unwrap();
    let rejected = app
        .call(
            BootRequest::new(HttpMethod::Get, "/hello")
                .with_header("accept-encoding", "gzip;q=0, br"),
        )
        .await
        .unwrap();

    assert_eq!(no_header.header("content-encoding"), None);
    assert_eq!(no_header.body_text().unwrap(), "hello hello hello hello");
    assert_eq!(rejected.header("content-encoding"), None);
    assert_eq!(rejected.body_text().unwrap(), "hello hello hello hello");
}

#[tokio::test]
async fn compression_interceptor_respects_min_size_and_existing_encoding() {
    let app = BootApplication::builder()
        .use_global_compression(CompressionOptions::new().with_min_size(32))
        .route(
            RouteDefinition::get("/small", |_| async { Ok(BootResponse::text("small")) }).unwrap(),
        )
        .route(
            RouteDefinition::get("/encoded", |_| async {
                Ok(BootResponse::text("already encoded").with_header("content-encoding", "br"))
            })
            .unwrap(),
        )
        .build()
        .unwrap();

    let small = app
        .call(BootRequest::new(HttpMethod::Get, "/small").with_header("accept-encoding", "gzip"))
        .await
        .unwrap();
    let encoded = app
        .call(BootRequest::new(HttpMethod::Get, "/encoded").with_header("accept-encoding", "gzip"))
        .await
        .unwrap();

    assert_eq!(small.header("content-encoding"), None);
    assert_eq!(small.body_text().unwrap(), "small");
    assert_eq!(encoded.header("content-encoding"), Some("br"));
    assert_eq!(encoded.body_text().unwrap(), "already encoded");
}

#[tokio::test]
async fn compression_interceptor_updates_content_length_when_body_changes() {
    let app = BootApplication::builder()
        .use_global_compression(CompressionOptions::new().with_min_size(1))
        .route(
            RouteDefinition::get("/json", |_| async {
                let response = BootResponse::json(&json!({
                    "message": "hello hello hello hello"
                }))?;
                let content_length = response.body().len() as u64;
                Ok(response.with_content_length(content_length))
            })
            .unwrap(),
        )
        .build()
        .unwrap();

    let response = app
        .call(BootRequest::new(HttpMethod::Get, "/json").with_header("accept-encoding", "gzip"))
        .await
        .unwrap();

    response.validate_content_length().unwrap();
    assert_eq!(response.header("content-encoding"), Some("gzip"));
    assert_eq!(
        response.content_length().unwrap(),
        Some(response.body().len() as u64)
    );
    assert_eq!(
        decode_gzip(response.body()).unwrap(),
        r#"{"message":"hello hello hello hello"}"#
    );
}

fn decode_gzip(bytes: &[u8]) -> std::io::Result<String> {
    let mut decoder = GzDecoder::new(bytes);
    let mut output = String::new();
    decoder.read_to_string(&mut output)?;
    Ok(output)
}