nut 0.1.4

Bolt DB Port 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

use crate::db::tests::db_mock;
use crate::errors::Error;
use crate::tx::WeakTx;

use super::Bucket;

pub(crate) fn bucket_mock(tx: WeakTx) -> Bucket {
    Bucket::new(tx)
}

#[test]
fn create() {
    let mut db = db_mock().build().unwrap();
    let mut tx = db.begin_rw_tx().unwrap();
    assert!(tx.bucket(b"foo").is_err());

    let mut bucket = tx.create_bucket(b"foo").unwrap();
    assert!(bucket.get(b"bar").is_none());

    bucket.put(b"foo", b"jaja".to_vec()).unwrap();
    assert!(bucket.get(b"foo").is_some());
    assert_eq!(bucket.get(b"foo").unwrap(), b"jaja");

    bucket.create_bucket(b"subbucket").unwrap();
    assert!(bucket.get(b"subbucket").is_none());
    assert!(bucket.bucket(b"subbucket").is_some());
}

#[test]
fn create_nested_buckets() {
    let path = {
        let mut db = db_mock().autoremove(false).build().unwrap();
        let mut tx = db.begin_rw_tx().unwrap();
        assert!(tx.bucket(b"foo").is_err());

        tx.create_bucket(b"foo")
            .unwrap()
            .create_bucket(b"foob")
            .unwrap()
            .create_bucket(b"fooc")
            .unwrap()
            .create_bucket(b"food")
            .unwrap()
            .create_bucket(b"fooe")
            .unwrap();

        assert!(tx
            .bucket(b"foo")
            .unwrap()
            .bucket(b"foob")
            .unwrap()
            .bucket(b"fooc")
            .unwrap()
            .bucket(b"food")
            .unwrap()
            .bucket(b"fooe")
            .is_some());

        tx.commit().unwrap();
        db.path().to_owned()
    };

    let db = db_mock().path(path).build().unwrap();
    let tx = db.begin_tx().unwrap();
    assert!(tx
        .bucket(b"foo")
        .unwrap()
        .bucket(b"foob")
        .unwrap()
        .bucket(b"fooc")
        .unwrap()
        .bucket(b"food")
        .unwrap()
        .bucket(b"fooe")
        .is_some());
}

#[test]
fn delete_value() {
    let mut db = db_mock().build().unwrap();
    let mut tx = db.begin_rw_tx().unwrap();
    {
        let mut bucket = tx.create_bucket(b"bucket").unwrap();
        bucket.put(b"haley", b"smith".to_vec()).unwrap();
        assert_eq!(bucket.get(b"haley").unwrap(), b"smith");
        bucket.delete(b"haley").unwrap();
        assert_eq!(bucket.get(b"haley"), None);
    }
    tx.commit().unwrap();
}

#[test]
fn delete_bucket_err() {
    let mut db = db_mock().build().unwrap();
    let mut tx = db.begin_rw_tx().unwrap();
    {
        let mut bucket = tx.create_bucket(b"bucket").unwrap();
        bucket.create_bucket(b"stan").unwrap();
        bucket.bucket(b"stan").unwrap();
        assert_eq!(bucket.delete(b"stan"), Err(Error::IncompatibleValue));
    }
    tx.commit().unwrap();
}