etebase 0.6.1

A Rust client library for Etebase
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

// SPDX-FileCopyrightText: © 2020 EteSync Authors
// SPDX-License-Identifier: LGPL-2.1-only

mod common;

use common::{sessionStorageKey, test_url, TestUser, USER};
use etebase::error::Result;
use etebase::{
    fs_cache::FileSystemCache,
    utils::{from_base64, randombytes, to_base64},
    Account, Client, ItemMetadata,
};
use remove_dir_all::remove_dir_all;
use std::env;
use std::io;
use std::path::{Path, PathBuf};

const CLIENT_NAME: &str = "etebase-tests";

pub struct TempDir {
    path: PathBuf,
}

impl TempDir {
    pub fn new() -> io::Result<TempDir> {
        etebase::init().unwrap();

        let tmpdir = env::temp_dir();
        let randbytes = randombytes(10);
        let rand = to_base64(&randbytes).unwrap();
        let name = format!("etebase-test-{}", rand);

        let path = tmpdir.join(name);
        match std::fs::create_dir(&path) {
            Ok(_) => Ok(TempDir { path }),
            Err(e) => Err(e),
        }
    }

    pub fn path(&self) -> &Path {
        self.path.as_path()
    }
}

impl Drop for TempDir {
    fn drop(&mut self) {
        remove_dir_all(&self.path).unwrap();
    }
}

fn init_test_local(user: &TestUser) -> Result<Account> {
    etebase::init()?;

    let client = Client::new(CLIENT_NAME, &test_url())?;
    let session_key = from_base64(sessionStorageKey)?;

    let ret = Account::restore(client, user.storedSession, Some(&session_key))?;

    Ok(ret)
}

#[test]
fn simple_cache_handling() -> Result<()> {
    let client = Client::new(CLIENT_NAME, &test_url())?;
    let etebase = init_test_local(&USER)?;
    let col_mgr = etebase.collection_manager()?;
    let meta = ItemMetadata::new()
        .set_name(Some("Collection"))
        .set_description(Some("Mine"))
        .set_color(Some("#aabbcc"))
        .clone();
    let content = b"SomeContent";

    let col = col_mgr.create("some.coltype", &meta, content)?;

    let temp_dir = TempDir::new()?;
    let fs_cache = FileSystemCache::new(temp_dir.path(), USER.username)?;

    assert!(fs_cache.load_account(&client, None).is_err());
    fs_cache.save_account(&etebase, None)?;
    fs_cache.load_account(&client, None)?;

    assert!(fs_cache.load_stoken()?.is_none());
    fs_cache.save_stoken("test")?;
    assert_eq!(fs_cache.load_stoken()?.unwrap(), "test");
    fs_cache.save_stoken("test2")?;
    assert_eq!(fs_cache.load_stoken()?.unwrap(), "test2");

    assert!(fs_cache.collection(&col_mgr, col.uid()).is_err());
    fs_cache.collection_set_with_content(&col_mgr, &col)?;
    let col2 = fs_cache.collection(&col_mgr, col.uid())?;
    assert_eq!(col2.meta_raw()?, col.meta_raw()?);
    assert_eq!(col2.content()?, col.content()?);

    assert!(fs_cache.collection_load_stoken(col.uid())?.is_none());
    fs_cache.collection_save_stoken(col.uid(), "test")?;
    assert_eq!(fs_cache.collection_load_stoken(col.uid())?.unwrap(), "test");
    fs_cache.collection_save_stoken(col.uid(), "test2")?;
    assert_eq!(
        fs_cache.collection_load_stoken(col.uid())?.unwrap(),
        "test2"
    );

    fs_cache.collection_unset(&col_mgr, col.uid())?;
    assert!(fs_cache.collection(&col_mgr, col.uid()).is_err());
    assert!(fs_cache.collection_load_stoken(col.uid())?.is_none());

    fs_cache.collection_set_with_content(&col_mgr, &col)?;
    let item_mgr = col_mgr.item_manager(&col)?;
    let item = {
        let meta = ItemMetadata::new().set_name(Some("Item 1")).clone();
        let content = b"Content 1";
        item_mgr.create(&meta, content)?
    };

    assert!(fs_cache.item(&item_mgr, col.uid(), item.uid()).is_err());
    fs_cache.item_set_with_content(&item_mgr, col.uid(), &item)?;
    let item2 = fs_cache.item(&item_mgr, col.uid(), item.uid())?;
    assert_eq!(item2.meta_raw()?, item.meta_raw()?);
    assert_eq!(item2.content()?, item.content()?);

    let item = {
        let meta = ItemMetadata::new().set_name(Some("Item 2")).clone();
        let content = b"Content 2";
        item_mgr.create(&meta, content)?
    };
    fs_cache.item_set_with_content(&item_mgr, col.uid(), &item)?;

    let cache_response = fs_cache.collection_list_raw()?;
    assert_eq!(1, cache_response.count());

    let cache_response = fs_cache.item_list_raw(col.uid())?;
    assert_eq!(2, cache_response.count());

    fs_cache.item_unset(&item_mgr, col.uid(), item.uid())?;
    assert!(fs_cache.item(&item_mgr, col.uid(), item.uid()).is_err());

    fs_cache.clear_user_cache()?;

    Ok(())
}