lb-rs 26.4.13

The rust library for interacting with your lockbook.
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

use lb_rs::io::network::ApiError;
use lb_rs::model::api::*;
use lb_rs::model::crypto::AESEncrypted;
use lb_rs::model::file_like::FileLike;
use lb_rs::model::file_metadata::FileDiff;
use lb_rs::model::meta::Meta;
use test_utils::*;

#[tokio::test]
async fn upsert_id_takeover() {
    let core1 = test_core_with_account().await;
    let core2 = test_core_with_account().await;

    let acc1 = &core1.get_account().unwrap();
    let acc2 = &core2.get_account().unwrap();

    let mut file1 = {
        let id = core1.create_at_path("/test.md").await.unwrap().id;
        core1.sync().await.unwrap();

        core1
            .client
            .request(acc1, GetUpdatesRequestV2 { since_metadata_version: 0 })
            .await
            .unwrap()
            .file_metadata
            .iter()
            .find(|&f| f.id() == &id)
            .unwrap()
            .clone()
    };

    match file1.timestamped_value.value {
        Meta::V1 { ref mut parent, .. } => *parent = core2.root().await.unwrap().id,
    }

    // If this succeeded account2 would be able to control file1
    let result = core2
        .client
        .request(acc2, UpsertRequestV2 { updates: vec![FileDiff::new(file1)] })
        .await;
    assert_matches!(
        result,
        Err(ApiError::<UpsertError>::Endpoint(UpsertError::OldVersionRequired))
    );
}

#[tokio::test]
async fn upsert_id_takeover_change_parent() {
    let core1 = test_core_with_account().await;
    let core2 = test_core_with_account().await;
    let account1 = core1.get_account().unwrap();
    let account2 = core2.get_account().unwrap();

    let file1 = {
        let id = core1.create_at_path("/test.md").await.unwrap().id;
        core1.sync().await.unwrap();
        core1
            .client
            .request(account1, GetUpdatesRequestV2 { since_metadata_version: 0 })
            .await
            .unwrap()
            .file_metadata
            .iter()
            .find(|&f| f.id() == &id)
            .unwrap()
            .clone()
    };

    // If this succeeded account2 would be able to control file1
    let result = core2
        .client
        .request(account2, UpsertRequestV2 { updates: vec![FileDiff::new(file1)] })
        .await;
    assert_matches!(
        result,
        Err(ApiError::<UpsertError>::Endpoint(UpsertError::OldVersionRequired))
    );
}

#[tokio::test]
async fn change_document_content() {
    let core1 = test_core_with_account().await;
    let core2 = test_core_with_account().await;

    let file1 = {
        let id = core1.create_at_path("/test.md").await.unwrap().id;
        core1.sync().await.unwrap();

        let mut tx = core1.begin_tx().await;
        tx.db().base_metadata.get().get(&id).unwrap().clone()
    };

    let mut file2 = file1.clone();
    file2
        .timestamped_value
        .value
        .set_hmac_and_size(Some([0; 32]), Some(1));

    let acc2 = &core2.get_account().unwrap();
    let result = core2
        .client
        .request(
            acc2,
            ChangeDocRequestV2 {
                diff: FileDiff::edit(file1, file2),
                new_content: AESEncrypted {
                    value: vec![69],
                    nonce: vec![69],
                    _t: Default::default(),
                },
            },
        )
        .await;
    assert_matches!(
        result,
        Err(ApiError::<ChangeDocError>::Endpoint(ChangeDocError::NotPermissioned))
    );
}

#[tokio::test]
async fn get_someone_else_document() {
    let core1 = test_core_with_account().await;
    let core2 = test_core_with_account().await;

    let file = {
        let id = core1.create_at_path("/test.md").await.unwrap().id;
        core1.write_document(id, &[1, 2, 3]).await.unwrap();
        core1.sync().await.unwrap();

        let mut tx = core1.begin_tx().await;
        tx.db().base_metadata.get().get(&id).unwrap().clone()
    };

    let req = GetDocRequest { id: *file.id(), hmac: *file.document_hmac().unwrap() };

    let acc2 = &core2.get_account().unwrap();
    let result = core2.client.request(acc2, req).await;
    assert_matches!(
        result,
        Err(ApiError::<GetDocumentError>::Endpoint(GetDocumentError::NotPermissioned))
    );
}