dharmadb 0.1.0

Persistent, fault tolerant 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

use crate::common::test_key::TestKey;
use crate::common::test_value::TestValue;
use crate::common::{cleanup_paths, get_test_data, get_test_data_in_range};
use dharmadb::errors::Errors;
use dharmadb::options::DharmaOpts;
use dharmadb::persistence::Persistence;
use dharmadb::storage::sorted_string_table_reader::SSTableReader;

mod common;

#[test]
fn test_create_persistence() {
    let options = DharmaOpts::default();
    cleanup_paths(&options);
    let persistence_result: Result<Persistence<TestKey>, Errors> =
        Persistence::create::<TestValue>(options);
    assert!(persistence_result.is_ok());
}

#[test]
fn test_insert_works() {
    let options = DharmaOpts::default();
    cleanup_paths(&options);
    let persistence_result: Result<Persistence<TestKey>, Errors> =
        Persistence::create::<TestValue>(options);
    let mut persistence = persistence_result.unwrap();
    let key = TestKey::from(1);
    let value = TestValue::from("Test Value");
    let insert_result = persistence.insert(key, value);
    assert!(insert_result.is_ok());
}

#[test]
fn test_flush_to_disk_works() {
    let options = DharmaOpts::default();
    cleanup_paths(&options);
    let data = get_test_data(200);
    let persistence_result: Result<Persistence<TestKey>, Errors> =
        Persistence::create::<TestValue>(options);
    let mut persistence = persistence_result.unwrap();
    let flush_result = persistence.flush(&data);
    assert!(flush_result.is_ok());
}

#[test]
fn test_persistence_get_after_flush() {
    let data = get_test_data(500);
    let options = DharmaOpts::default();
    cleanup_paths(&options);
    let persistence_result: Result<Persistence<TestKey>, Errors> =
        Persistence::create::<TestValue>(options);
    let mut persistence = persistence_result.unwrap();
    let flush_result = persistence.flush(&data);
    assert!(flush_result.is_ok());

    for (key, value) in data {
        let get_result: Result<Option<TestValue>, Errors> = persistence.get(&key);
        assert!(get_result.is_ok());
        let get_value = get_result.unwrap();
        assert!(get_value.is_some());
        assert_eq!(get_value.unwrap(), value);
    }
}

#[test]
fn test_flush_respects_compaction_threshold() {
    let options = DharmaOpts::default();
    let data_1 = get_test_data_in_range(0, 100);
    let data_2 = get_test_data_in_range(80, 300);
    let data_3 = get_test_data_in_range(280, 400);

    cleanup_paths(&options);
    let persistence_result: Result<Persistence<TestKey>, Errors> =
        Persistence::create::<TestValue>(options.clone());
    let mut persistence = persistence_result.unwrap();

    assert!(persistence.flush(&data_1).is_ok());
    assert!(persistence.flush(&data_2).is_ok());
    assert!(persistence.flush(&data_3).is_ok());

    let sstable_paths = SSTableReader::get_valid_table_paths(&options.path);
    assert!(sstable_paths.is_ok());
    assert_eq!(sstable_paths.unwrap().len(), 3);
}

#[test]
fn test_tables_are_compacted_after_threshold_is_met() {
    let options = DharmaOpts::default();
    cleanup_paths(&options);
    let data_1 = get_test_data_in_range(0, 100);
    let data_2 = get_test_data_in_range(80, 300);
    let data_3 = get_test_data_in_range(280, 400);
    let data_4 = get_test_data_in_range(400, 500);
    let persistence_result: Result<Persistence<TestKey>, Errors> =
        Persistence::create::<TestValue>(options.clone());
    let mut persistence = persistence_result.unwrap();

    assert!(persistence.flush(&data_1).is_ok());
    assert!(persistence.flush(&data_2).is_ok());
    assert!(persistence.flush(&data_3).is_ok());
    assert!(persistence.flush(&data_4).is_ok());

    let sstable_paths = SSTableReader::get_valid_table_paths(&options.path);
    assert!(sstable_paths.is_ok());
    assert_eq!(sstable_paths.unwrap().len(), 1);
}