tubes 0.6.3

Host/Client protocol based on pipenet
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

pub mod setup;

use setup::*;

#[test]
fn pairs() {
    let mut tests = [
        TestSession::new_pair(2000),
        #[cfg(all(feature = "encryption", feature = "compression"))]
        TestSession::new_pair_pack(2010),
    ];
    for s in tests.iter_mut() {
        check_cases(s);
    }
}

#[test]
fn triples() {
    let mut tests = [
        TestSession::new_triple(2001),
        #[cfg(all(feature = "encryption", feature = "compression"))]
        TestSession::new_triple_pack(2011),
    ];
    for s in tests.iter_mut() {
        check_cases(s);
    }
}

/// This test often fails, probably for some race conditions when too many
/// clients are used in the same host?
/// TODO: fix, figure it out
#[test]
#[ignore]
fn quads() {
    let mut tests = [
        TestSession::new_quad(2003),
        #[cfg(all(feature = "encryption", feature = "compression"))]
        TestSession::new_quad_pack(2013),
    ];
    for s in tests.iter_mut() {
        check_cases(s);
    }
}

fn check_cases(s: &mut TestSession) {
    let m: Msg = "mssgio".to_string().into();

    println!("TEST /// Broadcasting from server");
    s.server_broadcast(m.clone());
    s.assert_all_clients_received_broacast(s.server_uuid(), m.clone());

    println!("TEST /// Broadcasting from client");
    let uuid = s.first_client_broadcast(m.clone()).unwrap();
    println!("TEST ///     client: {uuid}");
    s.assert_server_received_broacast(uuid, m.clone());

    s.exhaust();

    println!("TEST /// Sending to specific client");
    let uuid = *s.clients().iter().next().unwrap();
    s.server_send_to(uuid, m.clone());
    s.assert_only_client_received(s.server_uuid(), uuid, m.clone());

    println!("TEST /// Sending to specific server");
    let uuid = s.first_client_send_to_server(m.clone()).unwrap();
    println!("TEST ///     client: {uuid}");
    s.assert_only_server_received(uuid, m.clone());

    println!("TEST /// Client leaving");
    s.client_leave(uuid);
    s.assert_client_left(uuid);
}

#[test]
fn promotion() {
    let mut s = TestSession::new_triple(2100);

    let promote = *s.clients().iter().next().unwrap();
    println!("TEST /// Promoting {promote} to server");
    s.promote_to_host(promote, 2104);

    println!("TEST /// Broadcasting after migration");
    let m: Msg = "promo".to_string().into();
    s.server_broadcast(m.clone());
    s.assert_all_clients_received_broacast(s.server_uuid(), m);
}