minerva 0.2.0

Causal ordering for distributed systems
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

extern crate alloc;

use crate::kairos::{Clock, Kairos, SkewExceeded, VirtualTimeSource};

#[test]
fn test_try_observe_accepts_within_bound() {
    // Within-bound remotes fold in exactly as `observe`.
    let clock = Clock::with_default_config(VirtualTimeSource::new(0), 1).unwrap();
    let remote = Kairos::new(100, 7, 2, 10u16);
    assert_eq!(clock.try_observe(remote, 100), Ok(()));
    assert_eq!(
        clock.stats().max_forward_skew_ns,
        100,
        "an admitted remote advances the clock exactly as observe does"
    );
    let next = clock.now(0u16);
    assert!(
        next > remote,
        "a mint after an admitted try_observe exceeds the remote"
    );
    assert_eq!(next.physical(), 100);
}

#[test]
fn test_try_observe_rejects_beyond_bound_and_leaves_clock_untouched() {
    // Rejected remotes leave no trace on state or skew stats.
    let clock = Clock::with_default_config(VirtualTimeSource::new(10), 1).unwrap();
    let first = clock.now(0u16); // (10, 0)
    let hostile = Kairos::new(10_000, 0, 2, 0u16); // 9_990 ahead of the reading
    assert_eq!(
        clock.try_observe(hostile, 100),
        Err(SkewExceeded {
            observed_forward_skew: 9_990,
            max_forward_skew: 100,
        }),
    );
    assert_eq!(
        clock.stats().max_forward_skew_ns,
        0,
        "a rejected remote contributes no forward skew"
    );
    let next = clock.now(0u16);
    assert!(next > first, "the clock still advances on its own");
    assert_eq!(
        next.physical(),
        10,
        "physical stays on local time; the rejected remote did not drag it forward"
    );
}

#[test]
fn test_try_observe_bound_is_inclusive() {
    let at = Clock::with_default_config(VirtualTimeSource::new(0), 1).unwrap();
    assert_eq!(at.try_observe(Kairos::new(100, 0, 2, 0u16), 100), Ok(()));

    let over = Clock::with_default_config(VirtualTimeSource::new(0), 1).unwrap();
    assert_eq!(
        over.try_observe(Kairos::new(101, 0, 2, 0u16), 100),
        Err(SkewExceeded {
            observed_forward_skew: 101,
            max_forward_skew: 100,
        }),
    );
}

#[test]
fn test_try_observe_admits_remote_behind_local() {
    // Forward skew only: behind-local remotes are admitted even at zero bound.
    let clock = Clock::with_default_config(VirtualTimeSource::new(500), 1).unwrap();
    let a = clock.now(0u16); // (500, 0)
    let behind = Kairos::new(100, 0, 2, 0u16);
    assert_eq!(
        clock.try_observe(behind, 0),
        Ok(()),
        "a behind-local remote passes even a zero bound"
    );
    let b = clock.now(0u16);
    assert!(b > a, "the receive still ticked the clock");
    assert_eq!(
        b.physical(),
        500,
        "local time is kept; the remote did not move physical"
    );
}