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

//! Declaration-basis validation at the local and delivery boundaries.

use super::*;

#[test]
fn a_witnessed_watermark_must_rise_to_the_declared_basis() {
    // Witnessing bottom does not establish coverage of a nonempty basis.
    let basis = cut(&[(1, 2), (2, 1)]);
    let mut epochs = machine();
    let fresh = tracker();
    assert_eq!(
        fresh.watermark_cut(),
        Some(Cut::bottom()),
        "witnessed is not risen: the hazard this pin exists for"
    );
    assert_eq!(
        epochs.declare(d(1, 3), Kairos::new(1, 0, 1, 0u16), &fresh, &basis),
        Err(EpochRefusal::Unrisen {
            station: 1,
            required: 2,
            witnessed: 0,
        })
    );
    assert_eq!(epochs.candidates().count(), 0, "no window opened");

    let mut risen = tracker();
    for station in ROSTER {
        risen.report_cut(station, &basis).unwrap();
    }
    assert!(
        epochs
            .declare(d(1, 3), Kairos::new(1, 0, 1, 0u16), &risen, &basis)
            .is_ok(),
        "a watermark exactly at the basis is risen"
    );
}

#[test]
fn a_bottom_basis_licenses_the_first_epoch() {
    // The caller explicitly licenses an empty initial generation.
    let mut epochs = machine();
    assert!(
        epochs
            .declare(
                d(1, 1),
                Kairos::new(1, 0, 1, 0u16),
                &tracker(),
                &Cut::bottom()
            )
            .is_ok()
    );
}

#[test]
fn an_unrisen_peer_declaration_refuses_identically_everywhere() {
    let vacuous = machine()
        .declare(
            d(1, 1),
            Kairos::new(1, 0, 1, 0u16),
            &tracker(),
            &Cut::bottom(),
        )
        .unwrap();
    let basis = cut(&[(2, 3)]);
    for _ in 0..2 {
        let mut receiver = machine();
        assert_eq!(
            receiver.deliver(vacuous.clone(), &tracker(), &basis),
            Err(EpochRefusal::Unrisen {
                station: 2,
                required: 3,
                witnessed: 0,
            })
        );
        assert_eq!(receiver.candidates().count(), 0, "no window opened");
    }
}