veilid-tools 0.5.4

A collection of baseline tools for Rust development use by Veilid and Veilid-enabled Rust applications
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

use crate::*;

pub async fn test_startup_shutdown() {
    info!("test_startup_shutdown");

    let bus = EventBus::new();

    // Normal case
    bus.startup().expect("should startup");
    bus.shutdown().await;

    // Startup fail case
    bus.startup().expect("should startup");
    bus.startup().expect_err("should not startup a second time");
    bus.shutdown().await;

    // Multiple shutdown case
    bus.startup().expect("should startup");
    bus.shutdown().await;
    bus.shutdown().await;
}

struct Evt1 {
    field1: i32,
}

struct Evt2 {
    field1: i32,
    field2: i64,
}

pub async fn test_post() {
    info!("test_post");

    let bus = EventBus::new();

    bus.post("test").expect_err("should fail");

    bus.startup().expect("should startup");
    bus.post("test").expect("should post");
    bus.post(Evt1 { field1: 0 }).expect("should post");
    bus.post(Evt2 {
        field1: 1,
        field2: 2,
    })
    .expect("should post");
    bus.shutdown().await;
}

pub async fn test_subscribe() {
    info!("test_subscribe");

    let bus = EventBus::new();

    // Okay to subscribe at any time
    bus.subscribe(|evt: Arc<Evt1>| {
        Box::pin(async move {
            assert_eq!(evt.field1, 0);
        })
    });

    // Startup keeps existing subscriptions
    bus.startup().expect("should startup");

    // Okay to subscribe at any time
    bus.subscribe(|evt: Arc<Evt2>| {
        Box::pin(async move {
            assert_eq!(evt.field1, 1);
            assert_eq!(evt.field2, 2);
        })
    });

    // Shutdown clears subscriptions
    bus.shutdown().await;
}

pub async fn test_post_subscribe() {
    info!("test_post_subscribe");

    let bus = EventBus::new();

    // Should calculate this total
    let total = Arc::new(AtomicUsize::new(0));

    // Okay to subscribe at any time
    let total2 = total.clone();
    bus.subscribe(move |evt: Arc<Evt1>| {
        let total = total2.clone();
        Box::pin(async move {
            assert_eq!(evt.field1, 0);

            total.fetch_add(1, Ordering::AcqRel);
        })
    });
    bus.post(Evt1 { field1: 0 }).expect_err("should fail");

    // Startup keeps existing subscriptions
    bus.startup().expect("should startup");

    bus.post("test").expect("should post");
    bus.post(Evt1 { field1: 0 }).expect("should post");
    bus.post(Evt2 {
        field1: 1,
        field2: 2,
    })
    .expect("should post");

    // Wait for all posts to process
    while !bus.is_empty() {
        sleep(250).await;
    }

    // Okay to subscribe at any time
    let total2 = total.clone();
    bus.subscribe(move |evt: Arc<Evt2>| {
        let total = total2.clone();
        Box::pin(async move {
            assert_eq!(evt.field1, 1);
            assert_eq!(evt.field2, 2);
            total.fetch_add(10, Ordering::AcqRel);
        })
    });

    bus.post("test").expect("should post");
    bus.post(Evt1 { field1: 0 }).expect("should post");
    bus.post(Evt2 {
        field1: 1,
        field2: 2,
    })
    .expect("should post");

    // Wait for all posts to process
    while !bus.is_empty() {
        sleep(250).await;
    }

    // Shutdown clears subscriptions
    bus.shutdown().await;

    // Should fail since we're shut down
    bus.post(Evt1 { field1: 0 }).expect_err("should fail");

    // Startup keeps existing subscriptions
    bus.startup().expect("should startup");

    // Succeeds but has no subscriptions
    bus.post(Evt1 { field1: 0 }).expect("should post");

    // Shutdown cleanly
    bus.shutdown().await;

    // Should have gotten this total
    // Two Evt1 processed, and one Evt2 processed
    assert_eq!(total.load(Ordering::Acquire), 12);
}

pub async fn test_all() {
    test_startup_shutdown().await;
    test_post().await;
    test_subscribe().await;
    test_post_subscribe().await;
}