graphyne 0.2.5

A simple rust client for sending messages to Graphite
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

#[cfg(test)]
mod tests {
    use graphyne::GraphiteClient;
    use std::net::TcpListener;
    use std::time::Duration;

    // Dummy listener that accepts connections
    struct DummyGraphiteServer {
        _handle: std::thread::JoinHandle<()>,
    }

    impl DummyGraphiteServer {
        fn start(port: u16) -> Self {
            let handle = std::thread::spawn(move || {
                let listener = TcpListener::bind(format!("127.0.0.1:{}", port)).unwrap();
                while listener.accept().is_ok() {
                    // Just accept and drop the connection
                }
            });

            // pause to start -- seems to be a race without waiting
            std::thread::sleep(Duration::from_millis(50));

            Self { _handle: handle }
        }
    }

    #[test]
    fn test_client_builder_defaults() {
        let port = 20031;
        let _ = DummyGraphiteServer::start(port);

        let client = GraphiteClient::builder()
            .address("127.0.0.1")
            .port(port)
            .build()
            .unwrap();
        insta::with_settings!({filters => vec![
            (r"        addr: [\d.]+:\d+", "        addr: <EPHEMERAL>"),
            (r"        fd: \d+", "        fd: <EPHEMERAL>"),
        ]}, {
            insta::assert_debug_snapshot!(client);
        });
    }

    #[test]
    fn test_client_builder_custom_retries() {
        let port = 20032;
        let _ = DummyGraphiteServer::start(port);

        let client = GraphiteClient::builder()
            .address("127.0.0.1")
            .port(port)
            .retries(10)
            .build()
            .unwrap();

        insta::with_settings!({filters => vec![
            (r"        addr: [\d.]+:\d+", "        addr: <EPHEMERAL>"),
            (r"        fd: \d+", "        fd: <EPHEMERAL>"),
        ]}, {
            insta::assert_debug_snapshot!(client);
        });
    }

    #[test]
    fn test_client_builder_custom_timeout() {
        let port = 20033;
        let _ = DummyGraphiteServer::start(port);

        let client = GraphiteClient::builder()
            .address("127.0.0.1")
            .port(port)
            .timeout(Duration::from_millis(100))
            .build()
            .unwrap();

        insta::with_settings!({filters => vec![
            (r"        addr: [\d.]+:\d+", "        addr: <EPHEMERAL>"),
            (r"        fd: \d+", "        fd: <EPHEMERAL>"),
        ]}, {
            insta::assert_debug_snapshot!(client);
        });
    }

    #[test]
    fn test_client_builder_all_options() {
        let port = 20034;
        let _ = DummyGraphiteServer::start(port);

        let client = GraphiteClient::builder()
            .address("127.0.0.1")
            .port(port)
            .retries(7)
            .timeout(Duration::from_secs(3))
            .build()
            .unwrap();

        insta::with_settings!({filters => vec![
            (r"        addr: [\d.]+:\d+", "        addr: <EPHEMERAL>"),
            (r"        fd: \d+", "        fd: <EPHEMERAL>"),
        ]}, {
            insta::assert_debug_snapshot!(client);
        });
    }

    #[test]
    fn test_connection_failure() {
        let result = GraphiteClient::builder()
            .address("127.0.0.1")
            .port(6969)
            .timeout(Duration::from_millis(100))
            .build();

        assert!(result.is_err());
    }
}