time-lib 0.2.1

Rust library to manage personal time
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

use std::time::Duration;
use time::{
    client::tcp::TcpClient,
    server::{tcp::TcpBind, ServerBuilder, ServerEvent},
    timer::{Timer, TimerCycle, TimerEvent, TimerState},
};

static HOST: &str = "127.0.0.1";
static PORT: u16 = 3000;

#[tokio::test(flavor = "multi_thread")]
async fn multiple_tcp_clients() {
    env_logger::builder().is_test(true).init();

    let server = ServerBuilder::new()
        .with_server_handler(|event: ServerEvent| async move {
            println!("server event: {event:?}");
            Ok(())
        })
        .with_timer_handler(|event: TimerEvent| async move {
            println!("timer event: {event:?}");
            Ok(())
        })
        .with_binder(TcpBind::new(HOST, PORT))
        .with_cycle(("Work", 3))
        .with_cycle(("Break", 5))
        .build()
        .unwrap();

    server
        .bind_with(|| async {
            // wait for the binder to be ready
            tokio::time::sleep(Duration::from_secs(1)).await;

            let client1 = TcpClient::new(HOST, PORT);
            let client2 = TcpClient::new(HOST, PORT);

            client1.start().await.unwrap();
            tokio::time::sleep(Duration::from_secs(2)).await;

            assert_eq!(
                client1.get().await.unwrap(),
                Timer {
                    state: TimerState::Running,
                    cycle: TimerCycle::new("Work", 1),
                    ..Timer::default()
                }
            );

            client1.pause().await.unwrap();
            tokio::time::sleep(Duration::from_secs(2)).await;

            assert_eq!(
                client2.get().await.unwrap(),
                Timer {
                    state: TimerState::Paused,
                    cycle: TimerCycle::new("Work", 1),
                    elapsed: 2,
                    ..Timer::default()
                }
            );

            client1.resume().await.unwrap();
            tokio::time::sleep(Duration::from_secs(2)).await;

            assert_eq!(
                client1.get().await.unwrap(),
                Timer {
                    state: TimerState::Running,
                    cycle: TimerCycle::new("Break", 4),
                    elapsed: 2,
                    ..Timer::default()
                }
            );

            tokio::time::sleep(Duration::from_secs(2)).await;

            assert_eq!(
                client1.get().await.unwrap(),
                Timer {
                    state: TimerState::Running,
                    cycle: TimerCycle::new("Break", 2),
                    elapsed: 2,
                    ..Timer::default()
                }
            );

            client2.stop().await.unwrap();

            assert_eq!(
                client2.get().await.unwrap(),
                Timer {
                    state: TimerState::Stopped,
                    cycle: TimerCycle::new("Work", 3),
                    ..Timer::default()
                }
            );

            Ok(())
        })
        .await
        .unwrap();
}