docdb 0.1.0

A lightweight and simple key-value store written in Rust
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

mod common;

use std::{thread, time::Duration};

use docdb::{DocDb, DumpPolicy, SerializationMethod};

#[test]
fn test_auto_dump() {
    let db_name = "auto_dump.db";

    // create a db with auto_dump == true
    let mut db = DocDb::new(&db_name, DumpPolicy::AutoDump, SerializationMethod::Yaml);

    assert!(db.set("num", &1).is_ok());

    // verify change in DB
    {
        let read_db = DocDb::load_read_only(db_name, SerializationMethod::Yaml).unwrap();
        assert_eq!(read_db.get::<i32>("num").unwrap(), 1);
    }

    // rem the key
    assert!(db.rem("num").unwrap_or(false));
    // verify change in DB
    {
        let read_db = DocDb::load_read_only(db_name, SerializationMethod::Yaml).unwrap();
        assert!(read_db.get::<i32>("num").is_none());
    }
}

#[test]
fn test_read_only_policy() {
    let db_name = "read_only.db";

    // create a db with read_only == true
    let mut db = DocDb::new(&db_name, DumpPolicy::AutoDump, SerializationMethod::Json);
    assert!(db.set("key", &String::from("this is key's val")).is_ok());

    let mut read_db = DocDb::load_read_only(db_name, SerializationMethod::Json).unwrap();

    assert!(read_db.set("key2", &"val2").is_ok());
    assert!(read_db.exist("key2"));

    // verify the set doesn't dump
    {
        let read_db2 = DocDb::load_read_only(db_name, SerializationMethod::Json).unwrap();
        assert!(read_db2.exist("key"));
        assert!(!read_db2.exist("key2"));
    }

    // try to dump db to the file, in fact just return ok()
    assert!(read_db.dump().is_ok());

    // verify the change doesn't dump
    {
        let read_db2 = DocDb::load_read_only(db_name, SerializationMethod::Json).unwrap();
        assert!(read_db2.exist("key"));
        assert!(!read_db2.exist("key2"));
    }

    drop(read_db);
    // verify the change doesn't dump
    {
        let read_db2 = DocDb::load_read_only(db_name, SerializationMethod::Json).unwrap();
        assert!(read_db2.exist("key"));
        assert!(!read_db2.exist("key2"));
    }
}

#[test]
fn test_rely_on_request_dump() {
    let db_name = "rely_on_request.db";

    // create a db with rely_on_request == true
    let mut db = DocDb::new(
        &db_name,
        DumpPolicy::DumpRelyRequest,
        SerializationMethod::Bin,
    );
    assert!(db.set("key", &String::from("this is key's val")).is_ok());

    // verify the db file not create yet
    assert!(DocDb::load_read_only(db_name, SerializationMethod::Bin).is_err());

    // dump file manully
    assert!(db.dump().is_ok());

    // verify the change is dumped to the file
    {
        let read_db = DocDb::load_read_only(db_name, SerializationMethod::Bin).unwrap();
        assert!(read_db.exist("key"));
    }

    // add more key
    db.set("key2", &1).unwrap();

    // drop db
    drop(db);

    // verify the key2 doesn't dumped
    {
        let read_db = DocDb::load_read_only(db_name, SerializationMethod::Bin).unwrap();
        assert!(read_db.exist("key"));
        assert!(!read_db.exist("key2"));
    }
}

#[test]
fn test_periodic_dump_policy() {
    let db_name = "periodid_db.db";

    // create a db with periodid_db == true
    let mut db = DocDb::new(
        &db_name,
        DumpPolicy::PeriodicDump(Duration::new(1, 0)),
        SerializationMethod::Bin,
    );
    assert!(db.set("key", &String::from("this is key's val")).is_ok());

    // verify the dump file not create yet
    assert!(DocDb::load_read_only(db_name, SerializationMethod::Bin).is_err());

    // sleep 0.5s
    thread::sleep(Duration::from_millis(500));

    // verify the dump file still not create yet
    assert!(DocDb::load_read_only(db_name, SerializationMethod::Bin).is_err());

    // sleep 0.55s again
    thread::sleep(Duration::from_millis(550));

    db.set("key2", &1).unwrap();
    // verify the file is created
    {
        let read_db = DocDb::load_read_only(db_name, SerializationMethod::Bin).unwrap();
        assert!(read_db.exist("key"));
        assert!(read_db.exist("key2"));
    }

    // add another key
    db.set("key3", &"val3").unwrap();
    // verify the key doesn't dump
    {
        let read_db = DocDb::load_read_only(db_name, SerializationMethod::Bin).unwrap();
        assert!(read_db.exist("key"));
        assert!(read_db.exist("key2"));
        assert!(!read_db.exist("key3"));
    }

    // add new key
    db.set("key4", &"val4").unwrap();

    // drop db
    drop(db);

    // verify key4 is dumped
    {
        let read_db = DocDb::load_read_only(db_name, SerializationMethod::Bin).unwrap();
        assert!(read_db.exist("key"));
        assert!(read_db.exist("key4"));
    }
}