rust-tokio-supervisor 0.1.2

A Rust tokio supervisor with declarative task supervision, restart policy, shutdown coordination, and observability.
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

//! Event journal tests.
//!
//! These tests verify fixed-capacity retention behavior.

use rust_supervisor::event::payload::{SupervisorEvent, What, Where};
use rust_supervisor::event::time::{CorrelationId, EventSequence, EventTime, When};
use rust_supervisor::id::types::{Attempt, Generation, SupervisorPath};
use rust_supervisor::journal::ring::EventJournal;
use uuid::Uuid;

/// Builds a deterministic event for journal tests.
/// Builds one deterministic journal event.
fn event(sequence: u64) -> SupervisorEvent {
    SupervisorEvent::new(
        When::new(EventTime::deterministic(
            sequence as u128,
            sequence as u128,
            0,
            Generation::initial(),
            Attempt::first(),
        )),
        Where::new(SupervisorPath::root()),
        What::ChildRunning { transition: None },
        EventSequence::new(sequence),
        CorrelationId::from_uuid(Uuid::nil()),
        1,
    )
}

/// Verifies recent event retention and dropped event accounting.
/// Verifies that the journal keeps recent events and counts dropped entries.
#[test]
fn journal_keeps_recent_events_and_counts_dropped_entries() {
    let mut journal = EventJournal::new(2);

    journal.push(event(1));
    journal.push(event(2));
    journal.push(event(3));

    let recent = journal.recent(2);
    assert_eq!(journal.len(), 2);
    assert_eq!(journal.dropped_count, 1);
    assert_eq!(journal.last_sequence, Some(EventSequence::new(3)));
    assert_eq!(recent[0].sequence.value, 2);
    assert_eq!(recent[1].sequence.value, 3);
}