aboutsummaryrefslogtreecommitdiffstats
path: root/src/simtest/holding.rs
blob: cbf194212e8eb226a3d26021163896b0196037ae (plain)
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
//! A swarm holding a store (`docs/store.md`, Members): nodes started from its root, or
//! joining by its ID, sync with the members its store names; the events put on any of
//! them reach all of them, and none reaches a node its party doesn't list.

use std::sync::Arc;
use std::time::Duration;

use super::{SOON, Sim, sim_key};
use crate::document::events;
use crate::federation::fold::Federation;
use crate::federation::harness::{self, Party, Spec};
use crate::federation::held::{self, Holding};
use crate::federation::store::{Fold, Id};
use crate::files::Files;
use crate::node::NodeConfig;
use crate::state::AppState;
use crate::swarm::bootstrap::{Origin, Start};

/// `config`, of a node of the swarm holding the store `id`, of `party`: started from the
/// store's `root` where given (`--store-root`), else joining by its ID (`--store-id`).
fn of_the_store(config: &mut NodeConfig, id: Id, party: &str, root: Option<&[u8]>) {
    config.store = Some(id);
    config.holding = Holding::open(
        None,
        Arc::new(Files::default()),
        None,
        Some(party.to_owned()),
    )
    .expect("no file to read");
    if let Some(root) = root {
        config.initial_doc = events::started(Federation::NAME, root).expect("a root");
    }
}

/// Whether `node` holds every event of `ids`.
fn holds(node: &AppState, ids: &[Id]) -> bool {
    node.holding
        .with(|store| ids.iter().all(|id| store.holds(id)))
        == Some(true)
}

/// tv lists a and b, which start from the root; lass lists c, which joins by the store's
/// ID; d is of lass too, which doesn't list it. Events put on a and on c reach a, b and
/// c; d, which no member syncs with, gets nothing.
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn the_events_put_on_a_member_reach_every_member_alone() {
    let sim = Sim::with_identity(81);
    let (tv, lass) = (Party::new("tv", 1), Party::new("lass", 2));
    let mut first = Spec::first(&[&tv, &lass], &[]);
    first.parties[0].nodes = vec![sim_key("a").id(), sim_key("b").id()];
    first.parties[1].nodes = vec![sim_key("c").id()];
    let root = first.root();
    let id = Id::of(&root);
    let a = sim.start_with("a", &[], Start::FromDocument(Origin::Root), |config| {
        of_the_store(config, id, "tv", Some(&root))
    });
    let b = sim.start_with("b", &["a"], Start::FromDocument(Origin::Root), |config| {
        of_the_store(config, id, "tv", Some(&root))
    });
    let c = sim.start_with("c", &["a"], Start::Join, |config| {
        of_the_store(config, id, "lass", None)
    });
    let members = [&a, &b, &c];
    sim.wait_ready(&members, SOON).await;
    sim.wait_until("a, b and c hold the store", SOON, move || async move {
        members.iter().all(|node| node.holding.tells_members())
    })
    .await;

    let d = sim.start_with("d", &["a"], Start::Join, |config| {
        of_the_store(config, id, "lass", None)
    });
    let on_a = tv.write(&[id], "home/tv/x", harness::str("1"));
    let on_c = lass.write(&[id], "home/lass/y", harness::str("2"));
    let ids = [Id::of(&on_a), Id::of(&on_c)];
    held::write(&a, None, on_a).await.expect("put on a");
    held::write(&c, None, on_c).await.expect("put on c");
    sim.wait_until("a, b and c hold both events", SOON, move || async move {
        members.iter().all(|node| holds(node, &ids))
    })
    .await;
    sim.wait_converged(&members, SOON).await;
    for node in members {
        assert_eq!(
            node.holding.with(|store| store.state().values().len()),
            Some(2)
        );
    }
    // Long enough for d to have joined, were it let in.
    tokio::time::sleep(Duration::from_secs(3)).await;
    assert!(!d.is_ready().await);
    assert!(!d.holding.tells_members());
    assert!(events::ids(&d.doc.read().await.doc).is_empty());
}