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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198

use lb_rs::model::ValidationFailure;
use lb_rs::model::errors::LbErrKind;
use lb_rs::model::file_metadata::FileType;
use lb_rs::model::path_ops::Filter::{DocumentsOnly, FoldersOnly, LeafNodesOnly};
use test_utils::*;

#[tokio::test]
async fn create_at_path_document() {
    let core = test_core_with_account().await;
    let doc = core.create_at_path("/document").await.unwrap();
    assert_eq!(doc.file_type, FileType::Document);
}

#[tokio::test]
async fn create_at_path_folder() {
    let core = test_core_with_account().await;
    let folder = core.create_at_path("/folder/").await.unwrap();
    assert_eq!(folder.file_type, FileType::Folder);
}

#[tokio::test]
async fn create_at_path_in_folder() {
    let core = test_core_with_account().await;

    let folder = core.create_at_path("/folder/").await.unwrap();
    let document = core.create_at_path("/folder/document").await.unwrap();

    assert_eq!(folder.file_type, FileType::Folder);
    assert_eq!(document.file_type, FileType::Document);
}

#[tokio::test]
async fn create_at_path_missing_folder() {
    let core = test_core_with_account().await;

    let document = core.create_at_path("/folder/document").await.unwrap();
    let folder = core.get_by_path("/folder").await.unwrap();

    assert_eq!(folder.file_type, FileType::Folder);
    assert_eq!(document.file_type, FileType::Document);
}

#[tokio::test]
async fn create_at_path_missing_folders() {
    let core = test_core_with_account().await;

    let document = core
        .create_at_path("/folder/folder/document")
        .await
        .unwrap();
    let folder1 = core.get_by_path("/folder").await.unwrap();
    let folder2 = core.get_by_path("/folder/folder").await.unwrap();

    assert_eq!(folder1.file_type, FileType::Folder);
    assert_eq!(folder2.file_type, FileType::Folder);
    assert_eq!(document.file_type, FileType::Document);
}

#[tokio::test]
async fn create_at_path_path_contains_empty_file_name() {
    let core = test_core_with_account().await;
    let result = core.create_at_path("//document").await;
    assert_matches!(result.unwrap_err().kind, LbErrKind::PathContainsEmptyFileName);
}

#[tokio::test]
async fn create_at_path_path_taken() {
    let core = test_core_with_account().await;
    core.create_at_path("/folder/document").await.unwrap();
    let result = core.create_at_path("/folder/document").await;
    assert_matches!(
        result.unwrap_err().kind,
        LbErrKind::Validation(ValidationFailure::PathConflict(_))
    );
}

#[tokio::test]
async fn create_at_path_not_folder() {
    let core = test_core_with_account().await;
    core.create_at_path("/not-folder").await.unwrap();
    let result = core.create_at_path("/not-folder/document").await;
    assert_matches!(
        result.unwrap_err().kind,
        LbErrKind::Validation(ValidationFailure::NonFolderWithChildren(_))
    );
}

#[tokio::test]
async fn get_by_path_document() {
    let core = test_core_with_account().await;
    let created_document = core.create_at_path("/document").await.unwrap();
    let document = core.get_by_path("/document").await.unwrap();
    assert_eq!(created_document, document);
}

#[tokio::test]
async fn get_by_path_folder() {
    let core = test_core_with_account().await;
    let created_folder = core.create_at_path("/folder/").await.unwrap();
    let folder = core.get_by_path("/folder").await.unwrap();
    assert_eq!(created_folder, folder);
}

#[tokio::test]
async fn get_by_path_document_in_folder() {
    let core = test_core_with_account().await;
    let created_document = core.create_at_path("/folder/document").await.unwrap();
    let document = core.get_by_path("/folder/document").await.unwrap();
    assert_eq!(created_document, document);
}

#[tokio::test]
async fn get_path_by_id_document() {
    let core = test_core_with_account().await;
    let document = core.create_at_path("/document").await.unwrap();
    let document_path = core.get_path_by_id(document.id).await.unwrap();
    assert_eq!(&document_path, "/document");
}

#[tokio::test]
async fn get_path_by_id_folder() {
    let core = test_core_with_account().await;
    let folder = core.create_at_path("/folder/").await.unwrap();
    let folder_path = core.get_path_by_id(folder.id).await.unwrap();
    assert_eq!(&folder_path, "/folder/");
}

#[tokio::test]
async fn get_path_by_id_document_in_folder() {
    let core = test_core_with_account().await;
    let document = core.create_at_path("/folder/document").await.unwrap();
    let document_path = core.get_path_by_id(document.id).await.unwrap();
    assert_eq!(&document_path, "/folder/document");
}

#[tokio::test]
async fn get_all_paths() {
    let core = test_core_with_account().await;

    core.create_at_path("/folder/folder/document")
        .await
        .unwrap();
    core.create_at_path("/folder/folder/folder/").await.unwrap();

    let all_paths = core.list_paths(None).await.unwrap();
    assert!(all_paths.iter().any(|p| p == "/"));
    assert!(all_paths.iter().any(|p| p == "/folder/"));
    assert!(all_paths.iter().any(|p| p == "/folder/folder/"));
    assert!(all_paths.iter().any(|p| p == "/folder/folder/document"));
    assert!(all_paths.iter().any(|p| p == "/folder/folder/folder/"));
    assert_eq!(all_paths.len(), 5);
}

#[tokio::test]
async fn get_all_paths_documents_only() {
    let core = test_core_with_account().await;

    core.create_at_path("/folder/folder/document")
        .await
        .unwrap();
    core.create_at_path("/folder/folder/folder/").await.unwrap();

    let all_paths = core.list_paths(Some(DocumentsOnly)).await.unwrap();
    assert!(all_paths.iter().any(|p| p == "/folder/folder/document"));
    assert_eq!(all_paths.len(), 1);
}

#[tokio::test]
async fn get_all_paths_folders_only() {
    let core = test_core_with_account().await;

    core.create_at_path("/folder/folder/document")
        .await
        .unwrap();
    core.create_at_path("/folder/folder/folder/").await.unwrap();

    let all_paths = core.list_paths(Some(FoldersOnly)).await.unwrap();
    assert!(all_paths.iter().any(|p| p == "/"));
    assert!(all_paths.iter().any(|p| p == "/folder/"));
    assert!(all_paths.iter().any(|p| p == "/folder/folder/"));
    assert!(all_paths.iter().any(|p| p == "/folder/folder/folder/"));
    assert_eq!(all_paths.len(), 4);
}

#[tokio::test]
async fn get_all_paths_leaf_nodes_only() {
    let core = test_core_with_account().await;

    core.create_at_path("/folder/folder/document")
        .await
        .unwrap();
    core.create_at_path("/folder/folder/folder/").await.unwrap();

    let all_paths = core.list_paths(Some(LeafNodesOnly)).await.unwrap();
    assert!(all_paths.iter().any(|p| p == "/folder/folder/folder/"));
    assert!(all_paths.iter().any(|p| p == "/folder/folder/document"));
    assert_eq!(all_paths.len(), 2);
}