socketioxide-redis 0.4.1

Redis adapter for the socket.io protocol
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

use std::time::Duration;

use socketioxide::extract::SocketRef;

mod fixture;

#[tokio::test]
pub async fn all_rooms() {
    let [io1, io2, io3] = fixture::spawn_servers();
    let handler =
        |rooms: &'static [&'static str]| async move |socket: SocketRef<_>| socket.join(rooms);

    io1.ns("/", handler(&["room1", "room2"])).await.unwrap();
    io2.ns("/", handler(&["room2", "room3"])).await.unwrap();
    io3.ns("/", handler(&["room3", "room1"])).await.unwrap();

    let ((_tx1, mut rx1), (_tx2, mut rx2), (_tx3, mut rx3)) = tokio::join!(
        io1.new_dummy_sock("/", ()),
        io2.new_dummy_sock("/", ()),
        io3.new_dummy_sock("/", ())
    );

    timeout_rcv!(&mut rx1); // Connect "/" packet
    timeout_rcv!(&mut rx2); // Connect "/" packet
    timeout_rcv!(&mut rx3); // Connect "/" packet

    const ROOMS: [&str; 3] = ["room1", "room2", "room3"];
    for io in [io1, io2, io3] {
        let mut rooms = io.rooms().await.unwrap();
        rooms.sort();
        assert_eq!(rooms, ROOMS);
    }

    timeout_rcv_err!(&mut rx1);
    timeout_rcv_err!(&mut rx2);
    timeout_rcv_err!(&mut rx3);
}

#[tokio::test]
pub async fn all_rooms_timeout() {
    const TIMEOUT: Duration = Duration::from_millis(50);
    let [io1, io2, io3] = fixture::spawn_buggy_servers(TIMEOUT);
    let handler =
        |rooms: &'static [&'static str]| async move |socket: SocketRef<_>| socket.join(rooms);

    io1.ns("/", handler(&["room1", "room2"])).await.unwrap();
    io2.ns("/", handler(&["room2", "room3"])).await.unwrap();
    io3.ns("/", handler(&["room3", "room1"])).await.unwrap();

    let ((_tx1, mut rx1), (_tx2, mut rx2), (_tx3, mut rx3)) = tokio::join!(
        io1.new_dummy_sock("/", ()),
        io2.new_dummy_sock("/", ()),
        io3.new_dummy_sock("/", ())
    );

    timeout_rcv!(&mut rx1); // Connect "/" packet
    timeout_rcv!(&mut rx2); // Connect "/" packet
    timeout_rcv!(&mut rx3); // Connect "/" packet

    const ROOMS: [&str; 3] = ["room1", "room2", "room3"];
    for io in [io1, io2, io3] {
        let now = std::time::Instant::now();
        let mut rooms = io.rooms().await.unwrap();
        assert!(now.elapsed() >= TIMEOUT); // timeout time
        rooms.sort();
        assert_eq!(rooms, ROOMS);
    }

    timeout_rcv_err!(&mut rx1);
    timeout_rcv_err!(&mut rx2);
    timeout_rcv_err!(&mut rx3);
}
#[tokio::test]
pub async fn add_sockets() {
    let handler = |room: &'static str| async move |socket: SocketRef<_>| socket.join(room);
    let [io1, io2] = fixture::spawn_servers();

    io1.ns("/", handler("room1")).await.unwrap();
    io2.ns("/", handler("room3")).await.unwrap();

    let ((_tx1, mut rx1), (_tx2, mut rx2)) =
        tokio::join!(io1.new_dummy_sock("/", ()), io2.new_dummy_sock("/", ()));

    timeout_rcv!(&mut rx1); // Connect "/" packet
    timeout_rcv!(&mut rx2); // Connect "/" packet
    io1.broadcast().join("room2").await.unwrap();
    let mut rooms = io1.rooms().await.unwrap();
    rooms.sort();
    assert_eq!(rooms, ["room1", "room2", "room3"]);

    timeout_rcv_err!(&mut rx1);
    timeout_rcv_err!(&mut rx2);
}

#[tokio::test]
pub async fn del_sockets() {
    let handler =
        |rooms: &'static [&'static str]| async move |socket: SocketRef<_>| socket.join(rooms);
    let [io1, io2] = fixture::spawn_servers();

    io1.ns("/", handler(&["room1", "room2"])).await.unwrap();
    io2.ns("/", handler(&["room3", "room2"])).await.unwrap();

    let ((_tx1, mut rx1), (_tx2, mut rx2)) =
        tokio::join!(io1.new_dummy_sock("/", ()), io2.new_dummy_sock("/", ()));

    timeout_rcv!(&mut rx1); // Connect "/" packet
    timeout_rcv!(&mut rx2); // Connect "/" packet

    io1.broadcast().leave("room2").await.unwrap();

    let mut rooms = io1.rooms().await.unwrap();
    rooms.sort();
    assert_eq!(rooms, ["room1", "room3"]);

    timeout_rcv_err!(&mut rx1);
    timeout_rcv_err!(&mut rx2);
}