kvs 0.0.6

Embedded Key-Value Store
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

#![cfg(feature = "serde")]

use kvs::adapters::ram::*;
use kvs::{KVStore, StoreConfig};

#[derive(serde::Serialize, serde::Deserialize, Debug, Eq, PartialEq)]
enum SensorMode {
    LowPower,
    Normal,
}

#[derive(serde::Serialize, serde::Deserialize, Debug, Eq, PartialEq)]
struct SensorConfig {
    offset: usize,
    prescaler: u8,
    mode: SensorMode,
}

mod tiny {
    use crate::*;

    pub const MAGIC: u32 = 0x796e6974;
    pub const STORE_SIZE: usize = 1024;
    pub const BUCKETS: usize = 32;
    pub const SLOTS: usize = 8;
    pub const MAX_HOPS: usize = 32;

    pub type Store = KVStore<MemoryAdapter<STORE_SIZE>, BUCKETS, SLOTS>;

    pub fn create_store() -> Store {
        Store::open(
            MemoryAdapter::default(),
            StoreConfig::new(MAGIC, MAX_HOPS),
            true,
        )
        .unwrap()
    }
}

const TEST_ENTRY: SensorConfig = SensorConfig {
    offset: 100500,
    prescaler: 42,
    mode: SensorMode::LowPower,
};

#[test]
fn test_create_store() {
    tiny::create_store();
}

#[test]
fn test_create() {
    let mut store = tiny::create_store();

    let bucket = store
        .insert_val::<SensorConfig, 16>(b"sensor/1", &TEST_ENTRY)
        .unwrap();
    assert_eq!(bucket.key_len(), 8);
    assert_eq!(bucket.val_len(), 5);
    assert_eq!(bucket.record_len(), 13);
}

#[test]
fn test_read() {
    let mut store = tiny::create_store();
    store
        .insert_val::<SensorConfig, 16>(b"sensor/1", &TEST_ENTRY)
        .unwrap();
    let entry = store.load_val::<SensorConfig, 16>(b"sensor/1").unwrap();
    assert_eq!(entry, TEST_ENTRY);
}

#[test]
fn test_delete() {
    let mut store = tiny::create_store();
    store
        .insert_val::<SensorConfig, 16>(b"sensor/1", &TEST_ENTRY)
        .unwrap();

    store.remove(b"sensor/1").unwrap();
    let res = store.load_val::<SensorConfig, 16>(b"sensor/1");
    assert_eq!(res, Err(kvs::Error::KeyNotFound));
}

#[test]
fn test_primitive_types() {
    let humidity = 225;
    let temp = 31_000;
    let charge = 100_500;

    let mut store = tiny::create_store();

    store.insert_val::<u8, 1>(b"humidity", &humidity).unwrap();
    store.insert_val::<u16, 3>(b"temp", &temp).unwrap();
    store.insert_val::<i32, 4>(b"charge", &charge).unwrap();

    assert_eq!(store.load_val::<u8, 1>(b"humidity").unwrap(), humidity);
    assert_eq!(store.load_val::<u16, 3>(b"temp").unwrap(), temp);
    assert_eq!(store.load_val::<i32, 4>(b"charge").unwrap(), charge);
}