jazz-rs 0.7.0

A framework for CRDT based, end-to-end enrypted distributed apps
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
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use futures::{Future, FutureExt, StreamExt};
use jazz_rs::{DocID, InvitationKind, Jazz};
use jmbl::Input;
use litl::Val;
use mofo::Mofo;
use caro::Remote;
use tracing::{debug, trace};
use std::time::Duration;

macro_rules! timeout {
    ($f:expr) => {
        tokio::time::timeout(Duration::from_millis(500), $f).map(|r| r.expect("Timed out"))
    };
}

#[tokio::test]
async fn can_create_team_and_share_document_for_reading() {
    // traceful::init_test_trace();

    let (_, _, background, setup_and_basic_assertions) =
        create_team_and_share_document(InvitationKind::Reader);

    background.run_until(setup_and_basic_assertions).await;
}

fn create_team_and_share_document(
    invitation_kind: InvitationKind,
) -> (Jazz, Jazz, Mofo, impl Future<Output = DocID>) {
    let background = Mofo::new();
    let jazz1 = Jazz::new("jazz1".to_string(), background.clone());
    let jazz2 = Jazz::new("jazz2".to_string(), background.clone());

    let setup = {
        let jazz1 = jazz1.clone();
        let jazz2 = jazz2.clone();

        async move {
            let team = timeout!(jazz1.create_team()).await;
            let doc = timeout!(jazz1.create_document(
                &team,
                Input::CollabMap(vec![("test".to_string(), Val::str("Hello World").into())]),
            ))
            .await;
            assert_eq!(
                doc.managed_jmbl.current_root().if_map().unwrap().to_litl(),
                Val::object([("test", Val::str("Hello World"))])
            );
            let invitation_token = team.create_invitation(
                invitation_kind,
                None,
                None,
                None,
                ti64::now() + 24 * 60 * 60 * 1000,
            )
            .await
            .unwrap();

            let (jazz1_as_remote, jazz2_as_remote) =
                Remote::new_connected_test_pair("jazz1", "jazz2");

            jazz1.add_remote(jazz2_as_remote).await;
            jazz2.add_remote(jazz1_as_remote).await;

            let jazz2 = jazz2.clone();

            debug!("invitation token: {:?}", invitation_token);
            jazz2.join_team(invitation_token).await.unwrap();
            let managed_doc2 = timeout!(jazz2.load_document(doc.id())).await.managed_jmbl;

            let doc2_updates = managed_doc2.updates("test2".to_owned());

            let (first_root, _) = timeout!(doc2_updates
                .filter(|(root, _)| {
                    let is_null = root.if_plain() == Ok(&Val::null());
                    trace!(root = ?root, is_null = is_null, "Got root");
                    futures::future::ready(!is_null)
                })
                .next())
            .await
            .unwrap();

            assert_eq!(
                first_root.if_map().unwrap().to_litl(),
                Val::object([("test", Val::str("Hello World"))])
            );

            doc.id()
        }
    };

    (jazz1, jazz2, background, setup)
}

#[tokio::test]
async fn can_create_team_and_share_document_for_writing() {
    // traceful::init_test_trace();

    let (jazz1, jazz2, background, setup_and_basic_assertions) =
        create_team_and_share_document(InvitationKind::Writer);

    background
        .run_until(async {
            // TODO: #70 wait until we definitely have write access, and make waiting for that easy

            let doc_id = setup_and_basic_assertions.await;

            let managed_doc2 = timeout!(jazz2.load_document(doc_id.clone()))
                .await
                .managed_jmbl;

            let write_view = managed_doc2.start_writing();
            write_view
                .get_root()
                .if_map_mut()
                .unwrap()
                .insert("test2", "Litl World");
            managed_doc2.finish_writing(write_view);

            assert_eq!(
                managed_doc2.current_root().if_map().unwrap().to_litl(),
                Val::object([
                    ("test", Val::str("Hello World")),
                    ("test2", Val::str("Litl World"))
                ])
            );

            let managed_doc1 = timeout!(jazz1.load_document(doc_id)).await.managed_jmbl;

            let doc1_updates = managed_doc1.updates("test1_after_sharing".to_owned());

            let (first_root_with_jazz2_update, _) = timeout!(doc1_updates
                .filter(|(root, _)| {
                    let has_update = root.if_map().unwrap().to_litl().get("test2").is_some();
                    trace!(root = ?root, has_update = has_update, "Got root");
                    futures::future::ready(has_update)
                })
                .next())
            .await
            .unwrap();

            assert_eq!(
                first_root_with_jazz2_update.if_map().unwrap().to_litl(),
                Val::object([
                    ("test", Val::str("Hello World")),
                    ("test2", Val::str("Litl World"))
                ])
            );
        })
        .await
}