wynd 0.11.1

A simple websocket library 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
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

#[cfg(test)]
mod tests {
    use std::sync::Arc;

    use tokio::time::{sleep, Duration};

    use crate::{
        conn::Connection,
        handle::ConnectionHandle,
        middleware::Next,
        wynd::{Standalone, Wynd},
    };

    #[tokio::test]
    async fn next_finalize_returns_same_conn_and_handle() {
        // This verifies that `Next::finalize()` acts as the end of the chain and simply
        // passes through its arguments.
        let next: Next<Standalone> = Next::finalize();

        // We don't have direct constructors, but `Next::call`'s semantics are:
        // Ok((conn, handle)) when there is no next middleware.
        // So we can just use `Arc::new_uninit()` which gives us distinct Arc pointers
        // that are still stable for equality checks.
        use std::mem::MaybeUninit;
        let raw_conn: Arc<MaybeUninit<Connection<Standalone>>> = Arc::new(MaybeUninit::uninit());
        let raw_handle: Arc<MaybeUninit<ConnectionHandle<Standalone>>> =
            Arc::new(MaybeUninit::uninit());

        // SAFETY: We never dereference these values, only compare Arc pointers, so the
        // inner uninitialized data is never read.
        let conn = unsafe {
            Arc::from_raw(Arc::into_raw(raw_conn.clone()) as *const Connection<Standalone>)
        };
        let handle = unsafe {
            Arc::from_raw(Arc::into_raw(raw_handle.clone()) as *const ConnectionHandle<Standalone>)
        };

        let (out_conn, out_handle) = next
            .call(Arc::clone(&conn), Arc::clone(&handle))
            .await
            .unwrap();

        assert!(Arc::ptr_eq(&conn, &out_conn));
        assert!(Arc::ptr_eq(&handle, &out_handle));

        // keep type in scope to avoid unused warnings
        let _phantom: Option<Wynd<Standalone>> = None;
    }

    #[tokio::test]
    async fn single_middleware_is_registered() {
        let mut wynd: Wynd<Standalone> = Wynd::new();

        // Track that middleware ran.
        let flag = Arc::new(tokio::sync::Mutex::new(false));
        let flag_clone = Arc::clone(&flag);

        wynd.use_middleware(move |conn, handle, next: Next<Standalone>| {
            let flag_clone = Arc::clone(&flag_clone);
            async move {
                {
                    let mut v = flag_clone.lock().await;
                    *v = true;
                }
                next.call(conn, handle).await
            }
        });

        assert_eq!(wynd.middlewares.len(), 1);

        // Sanity‑check that the flag is still false until the chain is executed.
        assert_eq!(*flag.lock().await, false);
    }

    #[tokio::test]
    async fn middleware_chain_runs_before_connection_handler() {
        let mut wynd: Wynd<Standalone> = Wynd::new();

        let called_flag = Arc::new(tokio::sync::Mutex::new(Vec::new()));
        let flag_a = called_flag.clone();
        wynd.use_middleware(move |conn, handle, next: Next<Standalone>| {
            let flag_a = flag_a.clone();
            async move {
                {
                    let mut v = flag_a.lock().await;
                    v.push("middleware-1");
                }
                next.call(conn, handle).await
            }
        });

        let flag_b = called_flag.clone();
        wynd.use_middleware(move |conn, handle, next: Next<Standalone>| {
            let flag_b = flag_b.clone();
            async move {
                {
                    let mut v = flag_b.lock().await;
                    v.push("middleware-2");
                }
                next.call(conn, handle).await
            }
        });

        let flag_c = called_flag.clone();
        wynd.on_connection(move |_conn| {
            let flag_c = flag_c.clone();
            async move {
                let mut v = flag_c.lock().await;
                v.push("handler");
            }
        });

        let port = 8085;
        let server = tokio::spawn(async move {
            let _ = wynd
                .listen(port, || {
                    println!("middleware test server started");
                })
                .await;
        });

        // Wait briefly for the server to start
        sleep(Duration::from_millis(50)).await;

        // Connect once to trigger the chain
        let url = format!("ws://127.0.0.1:{}", port);
        let (_ws, _) = tokio_tungstenite::connect_async(&url).await.unwrap();

        // Allow events to propagate
        sleep(Duration::from_millis(100)).await;

        let v = called_flag.lock().await.clone();
        // Shut down the server task
        server.abort();

        // We expect both middlewares then the handler.
        assert_eq!(v, vec!["middleware-1", "middleware-2", "handler"]);
    }
}