rullst 1.0.6

O framework fullstack definitivo para Rust, com foco em DX, velocidade e segurança.
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

use axum::{
    Json, Router,
    extract::Form,
    http::{HeaderValue, header},
    response::IntoResponse,
    routing::{get, post},
};
use rullst::testing::TestApp;
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct StatusJson {
    status: String,
    count: i32,
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct EchoMessage {
    message: String,
}

#[derive(Serialize, Deserialize)]
struct FormPayload {
    name: String,
}

// Route handlers
async fn handle_root() -> &'static str {
    "Welcome to Rullst!"
}

async fn handle_json() -> impl IntoResponse {
    Json(StatusJson {
        status: "ok".to_string(),
        count: 42,
    })
}

async fn handle_echo(Json(payload): Json<EchoMessage>) -> impl IntoResponse {
    let mut headers = axum::http::HeaderMap::new();
    headers.append(
        header::SET_COOKIE,
        HeaderValue::from_static("session_id=12345; Path=/; HttpOnly"),
    );
    headers.append(
        header::SET_COOKIE,
        HeaderValue::from_static("theme=dark; Path=/"),
    );
    (headers, Json(payload))
}

async fn handle_form(Form(payload): Form<FormPayload>) -> String {
    format!("Hello, {}!", payload.name)
}

fn build_router() -> Router {
    Router::new()
        .route("/", get(handle_root))
        .route("/json", get(handle_json))
        .route("/echo", post(handle_echo))
        .route("/form", post(handle_form))
}

#[tokio::test]
async fn test_e2e_get_plain_text() {
    let app = TestApp::new(build_router());

    app.get("/")
        .await
        .assert_status(200)
        .assert_see("Welcome to Rullst")
        .assert_dont_see("Goodbye");
}

#[tokio::test]
async fn test_e2e_get_json() {
    let app = TestApp::new(build_router());

    let expected = StatusJson {
        status: "ok".to_string(),
        count: 42,
    };

    app.get("/json")
        .await
        .assert_status(200)
        .assert_json(&expected);
}

#[tokio::test]
async fn test_e2e_post_json_and_cookies() {
    let app = TestApp::new(build_router());

    let payload = EchoMessage {
        message: "Hello Rust!".to_string(),
    };

    let response = app.post("/echo").json(&payload).await;

    response
        .assert_status(200)
        .assert_json(&payload)
        .assert_has_cookie("session_id")
        .assert_cookie("session_id", "12345")
        .assert_cookie("theme", "dark")
        .assert_header("content-type", "application/json");

    assert_eq!(
        response.cookie_value("session_id"),
        Some("12345".to_string())
    );
    assert_eq!(response.cookie_value("nonexistent_cookie"), None);
}

#[tokio::test]
async fn test_e2e_post_form() {
    let app = TestApp::new(build_router());

    let payload = FormPayload {
        name: "Antigravity".to_string(),
    };

    app.post("/form")
        .form(&payload)
        .await
        .assert_status(200)
        .assert_see("Hello, Antigravity!");
}