jazz-rs 0.2.8

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

use std::time::Duration;

use futures::Future;
use jazz_rs::{InvitationKind, Jazz, ScopedDocID};
use jmbl::Input;
use litl::Litl;
use log::{debug, info};
use mofo::Mofo;
use tlpt::Remote;

#[test_log::test(tokio::test)]
async fn can_create_team_and_share_document_for_reading() {
    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 = ScopedDocID>) {
    let background = Mofo::new("test");
    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 = jazz1.create_team().await;
            let (doc_id, managed_doc) = jazz1
                .create_document(
                    team,
                    Input::CollabMap(vec![(
                        "test".to_string(),
                        Litl::string("Hello World").into(),
                    )]),
                )
                .await;
            assert_eq!(
                managed_doc.current_root().if_map().unwrap().to_litl(),
                Litl::dict([("test", Litl::string("Hello World"))])
            );
            let invitation_token = jazz1
                .create_invitation(team, invitation_kind)
                .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 = jazz2.load_document(doc_id.clone()).await;

            // TODO: wait for something meaningful
            tokio::time::sleep(Duration::from_millis(100)).await;

            assert_eq!(
                managed_doc2.current_root().if_map().unwrap().to_litl(),
                Litl::dict([("test", Litl::string("Hello World"))])
            );

            doc_id
        }
    };

    (jazz1, jazz2, background, setup)
}

#[test_log::test(tokio::test)]
async fn can_create_team_and_share_document_for_writing() {
    let (jazz1, jazz2, background, setup_and_basic_assertions) =
        create_team_and_share_document(InvitationKind::Writer);

    background
        .run_until(async {
            let doc_id = setup_and_basic_assertions.await;

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

            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(),
                Litl::dict([
                    ("test", Litl::string("Hello World")),
                    ("test2", Litl::string("Litl World"))
                ])
            );

            let managed_doc1 = jazz1.load_document(doc_id).await;

            info!("TIMEOUT START");
            // TODO: wait for something meaningful
            tokio::time::sleep(Duration::from_millis(1000)).await;
            info!("TIMEOUT DONE");

            assert_eq!(
                managed_doc1.current_root().if_map().unwrap().to_litl(),
                Litl::dict([
                    ("test", Litl::string("Hello World")),
                    ("test2", Litl::string("Litl World"))
                ])
            );
        })
        .await
}