rapina 0.13.1

A fast, type-safe web framework for Rust inspired by FastAPI
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
138
139
140
141
142
143
144
145
146
147
148

//! Tests for JSON serialization in response types.

use http::StatusCode;
use rapina::prelude::*;
use rapina::testing::TestClient;
use serde::Serialize;
use std::fmt;

/// A type whose `Serialize` implementation returns an error, simulating any
/// real-world serialization failure (e.g. custom validation in `Serialize`,
/// IO errors on non-Vec sinks, etc.).
struct BrokenSerialize;

impl Serialize for BrokenSerialize {
    fn serialize<S: serde::Serializer>(
        &self,
        _serializer: S,
    ) -> std::result::Result<S::Ok, S::Error> {
        Err(serde::ser::Error::custom("serialization failed"))
    }
}

impl fmt::Debug for BrokenSerialize {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str("BrokenSerialize")
    }
}

#[tokio::test]
async fn test_status_code_json_tuple_returns_500_on_serialization_failure() {
    let app = Rapina::new()
        .with_introspection(false)
        .router(
            Router::new().route(http::Method::GET, "/bad", |_, _, _| async {
                (StatusCode::OK, Json(BrokenSerialize))
            }),
        );

    let client = TestClient::new(app).await;
    let response = client.get("/bad").send().await;

    assert_eq!(
        response.status(),
        StatusCode::INTERNAL_SERVER_ERROR,
        "serialization failure must produce 500, not the handler's original status"
    );

    let json: serde_json::Value = response.json();
    assert!(
        json.get("error").is_some() || json.get("code").is_some(),
        "response body must contain error details, got: {json}"
    );
}

#[tokio::test]
async fn test_status_code_json_tuple_500_on_201_with_serialization_failure() {
    let app = Rapina::new()
        .with_introspection(false)
        .router(
            Router::new().route(http::Method::POST, "/create", |_, _, _| async {
                (StatusCode::CREATED, Json(BrokenSerialize))
            }),
        );

    let client = TestClient::new(app).await;
    let response = client.post("/create").send().await;

    assert_eq!(
        response.status(),
        StatusCode::INTERNAL_SERVER_ERROR,
        "serialization failure must override even an explicit 201"
    );

    let json: serde_json::Value = response.json();
    assert!(
        json.get("error").is_some() || json.get("code").is_some(),
        "response body must contain error details, got: {json}"
    );
}

#[tokio::test]
async fn test_json_only_returns_500_on_serialization_failure() {
    let app = Rapina::new()
        .with_introspection(false)
        .router(
            Router::new().route(http::Method::GET, "/bad", |_, _, _| async {
                Json(BrokenSerialize)
            }),
        );

    let client = TestClient::new(app).await;
    let response = client.get("/bad").send().await;

    assert_eq!(
        response.status(),
        StatusCode::INTERNAL_SERVER_ERROR,
        "Json<T> wrapper must also produce 500 on serialization failure"
    );

    let json: serde_json::Value = response.json();
    assert!(
        json.get("error").is_some() || json.get("code").is_some(),
        "response body must contain error details, got: {json}"
    );
}

#[derive(Serialize, Debug)]
struct GoodData {
    value: i32,
}

#[tokio::test]
async fn test_valid_tuple_serialization_still_works() {
    let app = Rapina::new()
        .with_introspection(false)
        .router(
            Router::new().route(http::Method::GET, "/ok", |_, _, _| async {
                (StatusCode::OK, Json(GoodData { value: 42 }))
            }),
        );

    let client = TestClient::new(app).await;
    let response = client.get("/ok").send().await;

    assert_eq!(response.status(), StatusCode::OK);

    let json: serde_json::Value = response.json();
    assert_eq!(json["value"], 42);
}

#[tokio::test]
async fn test_valid_json_wrapper_still_works() {
    let app = Rapina::new()
        .with_introspection(false)
        .router(
            Router::new().route(http::Method::GET, "/ok", |_, _, _| async {
                Json(GoodData { value: 99 })
            }),
        );

    let client = TestClient::new(app).await;
    let response = client.get("/ok").send().await;

    assert_eq!(response.status(), StatusCode::OK);

    let json: serde_json::Value = response.json();
    assert_eq!(json["value"], 99);
}