sioc 0.3.1

Async Socket.IO client with type-safe event handling
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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171

use axum::Router;
use sioc::prelude::*;
use socketioxide::SocketIo;
use socketioxide::extract::{AckSender, Data, SocketRef};
use std::time::Duration;
use tokio::net::TcpListener;
use url::Url;

// sioc wire format: tuple struct fields become positional JSON args.
// Ping(42) -> ["ping", 42], Pong(42) -> ["pong", 42].
// On the socketioxide side we mirror this with (u32,) tuples.

#[derive(Debug, PartialEq, EventType, SerializePayload, DeserializePayload)]
struct Ping(u32);

#[derive(Debug, PartialEq, EventType, SerializePayload, DeserializePayload)]
struct Pong(u32);

#[derive(Debug, PartialEq, EventType, SerializePayload, DeserializePayload)]
#[sioc(event(ack = "Confirm"))]
struct PingWithAck(u32);

#[derive(Debug, PartialEq, EventType, SerializePayload, DeserializePayload)]
#[sioc(event(ack = "Confirm"))]
struct ServerPing(u32);

#[derive(Debug, PartialEq, AckType, SerializePayload, DeserializePayload)]
struct Confirm(bool);

#[derive(Debug, EventRouter)]
enum MyEvent {
    Pong(Event<Pong>),
    ServerPing(Event<ServerPing>),
}

async fn spawn_server(setup: impl FnOnce(&SocketIo)) -> u16 {
    let (layer, io) = SocketIo::new_layer();
    setup(&io);
    let app = Router::new().layer(layer);
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let port = listener.local_addr().unwrap().port();
    tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
    port
}

#[tokio::test]
async fn ws_connect() {
    let port = spawn_server(|io| {
        io.ns("/", async |_socket: SocketRef| {});
    })
    .await;
    let url = Url::parse(&format!("http://127.0.0.1:{port}")).unwrap();
    let client = ClientBuilder::new(url).open().unwrap();
    let (_tx, mut rx) = client.connect("/").await.unwrap();
    assert!(matches!(rx.recv().await.unwrap(), Signal::Connect(_)));
}

#[tokio::test]
async fn ws_emit_echo() {
    let port = spawn_server(|io| {
        io.ns("/", async |socket: SocketRef| {
            socket.on("ping", async |socket: SocketRef, Data::<(u32,)>((seq,))| {
                socket.emit("pong", &(seq,)).ok();
            });
        });
    })
    .await;
    let url = Url::parse(&format!("http://127.0.0.1:{port}")).unwrap();
    let client = ClientBuilder::new(url).open().unwrap();
    let (tx, mut rx) = client.connect("/").await.unwrap();
    rx.recv().await.unwrap();
    tx.emit(Ping(7)).await.unwrap();
    let event = rx.listen::<MyEvent>().await.unwrap().unwrap();
    assert!(matches!(
        event,
        MyEvent::Pong(Event {
            payload: Pong(7),
            ..
        })
    ));
}

#[tokio::test]
async fn ws_client_ack() {
    let port = spawn_server(|io| {
        io.ns("/", async |socket: SocketRef| {
            socket.on(
                "ping_with_ack",
                async |_: SocketRef, Data::<(u32,)>(_), ack: AckSender| {
                    ack.send(&(true,)).ok();
                },
            );
        });
    })
    .await;
    let url = Url::parse(&format!("http://127.0.0.1:{port}")).unwrap();
    let client = ClientBuilder::new(url).open().unwrap();
    let (tx, mut rx) = client.connect("/").await.unwrap();
    rx.recv().await.unwrap();
    let handle = tx.emit(PingWithAck(1)).await.unwrap();
    let Ack {
        payload: Confirm(ok),
        ..
    } = handle.timeout(Duration::from_secs(5)).await.unwrap();
    assert!(ok);
}

#[tokio::test]
async fn ws_server_ack() {
    let port = spawn_server(|io| {
        io.ns("/", async |socket: SocketRef| {
            let _ = socket
                .emit_with_ack::<(u32,), (bool,)>("server_ping", &(99u32,))
                .unwrap()
                .await;
        });
    })
    .await;
    let url = Url::parse(&format!("http://127.0.0.1:{port}")).unwrap();
    let client = ClientBuilder::new(url).open().unwrap();
    let (tx, mut rx) = client.connect("/").await.unwrap();
    rx.recv().await.unwrap();
    let event = rx.listen::<MyEvent>().await.unwrap().unwrap();
    let MyEvent::ServerPing(Event { id, .. }) = event else {
        panic!("wrong event");
    };
    tx.acknowledge(id, Confirm(true)).await.unwrap();
}

#[tokio::test]
async fn polling_connect() {
    let port = spawn_server(|io| {
        io.ns("/", async |_socket: SocketRef| {});
    })
    .await;
    let url = Url::parse(&format!("http://127.0.0.1:{port}")).unwrap();
    let client = ClientBuilder::new(url)
        .transport(TransportStrategy::Polling)
        .open()
        .unwrap();
    let (_tx, mut rx) = client.connect("/").await.unwrap();
    assert!(matches!(rx.recv().await.unwrap(), Signal::Connect(_)));
}

#[tokio::test]
async fn polling_emit_echo() {
    let port = spawn_server(|io| {
        io.ns("/", async |socket: SocketRef| {
            socket.on("ping", async |socket: SocketRef, Data::<(u32,)>((seq,))| {
                socket.emit("pong", &(seq,)).ok();
            });
        });
    })
    .await;
    let url = Url::parse(&format!("http://127.0.0.1:{port}")).unwrap();
    let client = ClientBuilder::new(url)
        .transport(TransportStrategy::Polling)
        .open()
        .unwrap();
    let (tx, mut rx) = client.connect("/").await.unwrap();
    rx.recv().await.unwrap();
    tx.emit(Ping(99)).await.unwrap();
    let event = rx.listen::<MyEvent>().await.unwrap().unwrap();
    assert!(matches!(
        event,
        MyEvent::Pong(Event {
            payload: Pong(99),
            ..
        })
    ));
}