volga 0.9.1

Easy & Fast Web Framework for Rust
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

#![allow(missing_docs)]
#![cfg(all(feature = "test", feature = "ws"))]

use volga::test::TestServer;

#[tokio::test]
async fn it_works() {
    let server = TestServer::spawn(|app| {
        app.map_msg("/ws", |msg: String| async { msg });
    })
    .await;

    let mut ws = server.ws("/ws").await;

    ws.send_text("Pass!").await;
    let response = ws.recv_text().await;

    assert_eq!(response, "Pass!");

    server.shutdown().await;
}

#[tokio::test]
async fn it_works_with_split() {
    use volga::ws::{WebSocket, WsEvent};

    let server = TestServer::spawn(|app| {
        app.map_ws("/ws", |ws: WebSocket| async move {
            let (mut write, mut read) = ws.split();
            while let Some(Ok(msg)) = read.recv::<String>().await {
                match msg {
                    WsEvent::Data(msg) => write.send(msg).await.unwrap(),
                    WsEvent::Close(_frame) => write.close().await.unwrap(),
                    _ => unreachable!(),
                }
            }
        });
    })
    .await;

    let mut ws = server.ws("/ws").await;

    ws.send_text("Pass!").await;
    let response = ws.recv_text().await;

    assert_eq!(response, "Pass!");

    server.shutdown().await;
}

#[tokio::test]
async fn it_works_with_custom_protocol() {
    use volga::ws::{WebSocket, WebSocketConnection, WsEvent};

    let server = TestServer::spawn(|app| {
        app.map_conn("/ws", |conn: WebSocketConnection| async {
            conn.with_protocols(["foo-ws"]).on(|ws: WebSocket| async {
                let protocol = ws.protocol().unwrap().to_str().unwrap().to_string();
                let (mut write, mut read) = ws.split();
                while let Some(Ok(msg)) = read.recv::<String>().await {
                    match msg {
                        WsEvent::Data(msg) => {
                            write.send(format!("[{protocol}]: {msg}")).await.unwrap()
                        }
                        WsEvent::Close(_frame) => write.close().await.unwrap(),
                        _ => unreachable!(),
                    }
                }
            })
        });
    })
    .await;

    let mut ws = server.ws_with_protocols("/ws", ["foo-ws"]).await;

    ws.send_text("Pass!").await;
    let response = ws.recv_text().await;

    assert_eq!(response, "[foo-ws]: Pass!");

    server.shutdown().await;
}

#[tokio::test]
async fn it_allows_ws_sink_stream_into_inner() {
    use futures_util::{SinkExt, StreamExt};

    let server = TestServer::spawn(|app| {
        app.map_ws("/ws", |ws: volga::ws::WebSocket| async move {
            let (write, read) = ws.split();
            let mut inner_sink = write.into_inner();
            let mut inner_stream = read.into_inner();
            if let Some(Ok(msg)) = inner_stream.next().await {
                inner_sink.send(msg).await.unwrap();
            }
        });
    })
    .await;

    let mut ws = server.ws("/ws").await;

    ws.send_text("hello").await;
    let response = ws.recv_text().await;

    assert_eq!(response, "hello");

    server.shutdown().await;
}