kcode-k1-groups 0.2.0

Synchronous facade over the K1 groups driver and projection
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

use std::{path::Path, sync::Arc};

use kcode_k1_groups::{GroupName, K1Groups, TxId, UserId};
use kcode_k1_peering::K1Peering;
use kcode_k1_txn_ordering::K1TxnOrdering;

fn assert_send_sync<T: Send + Sync>() {}

fn user(value: u8) -> UserId {
    UserId::from_tx_id(TxId::from_bytes([value; 12]))
}

fn name(value: &str) -> GroupName {
    GroupName::new(value.to_owned()).unwrap()
}

fn open_stack(root: &Path) -> (Arc<K1TxnOrdering>, Arc<K1Peering>, K1Groups) {
    let ordering = Arc::new(K1TxnOrdering::open(&root.join("ordering")).unwrap());
    let peering = Arc::new(K1Peering::open(&root.join("peering"), ordering.clone()).unwrap());
    let groups = K1Groups::open(&root.join("groups"), ordering.clone(), peering.clone()).unwrap();
    (ordering, peering, groups)
}

#[test]
fn create_rename_query_and_reopen() {
    assert_send_sync::<K1Groups>();
    let root = tempfile::tempdir().unwrap();
    let (ordering, peering, groups) = open_stack(root.path());

    let created = groups.create(user(1), name("created")).unwrap();
    let group = created.group_id();
    let renamed = groups.rename(user(1), group, name("renamed")).unwrap();
    let fetched = groups.get(group).unwrap().unwrap();
    assert_eq!(fetched.name().as_str(), "renamed");
    assert_eq!(fetched.revision(), &renamed);

    drop(groups);
    drop(peering);
    drop(ordering);

    let (ordering, peering, groups) = open_stack(root.path());
    let fetched = groups.get(group).unwrap().unwrap();
    assert_eq!(fetched.name().as_str(), "renamed");
    assert_eq!(fetched.revision(), &renamed);

    drop(groups);
    drop(peering);
    drop(ordering);
}