hyperbee 0.5.0

Peer to Peer B-tree
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

mod common;
use common::{
    parse_json_result,
    python::{require_python, run_python},
    write_range_to_hb, Result,
};
use hyperbee::Hyperbee;

#[tokio::test]
async fn test_sub_prefix() -> Result<()> {
    let x = match require_python() {
        Err(e) => {
            println!("{}", e);
            return Err(e);
        }
        Ok(x) => x,
    };
    dbg!(&x);
    let out = run_python(
        "
async def main():
    prefix = b'myprefix'
    key = b'keykey'
    val_no_pref = b'no prefix'
    val_with_pref = b'yes prefix'

    config = PrefixedConfig(bytes([0]))
    hb = await hyperbee_from_ram()
    sub_hb = await hb.sub(prefix, config)

    await hb.put(key, val_no_pref)
    await sub_hb.put(key, val_with_pref)

    x = await hb.get(key)
    assert(x.value == val_no_pref)

    x = await sub_hb.get(key)
    assert(x.value == val_with_pref)
",
    )?;
    dbg!(&out);
    assert_eq!(out.status.code(), Some(0));
    Ok(())
}

#[tokio::test]
async fn hello_world_get_set_del() -> Result<()> {
    let x = require_python()?;
    dbg!(&x);
    let out = run_python(
        "
async def main():
    hb = await hyperbee_from_ram()
    x = await hb.put(b'hello', b'world')
    assert(x.old_seq == None)
    assert(x.new_seq == 1)

    x = await hb.get(b'hello')
    assert(x.value == b'world')

    x = await hb.delete(b'hello')
    assert(x == 1)
",
    )?;
    dbg!(&out);
    assert_eq!(out.status.code(), Some(0));
    Ok(())
}

#[tokio::test]
async fn optionals() -> Result<()> {
    let _x = require_python()?;
    let storage_dir = tempfile::tempdir()?;
    {
        let hb = Hyperbee::from_storage_dir(&storage_dir).await?;
        let _ = hb.put(b"hello", None).await?;
    }
    let code = format!(
        "
async def main():
    import json
    hb = await hyperbee_from_storage_dir('{}')
    res = await hb.get(b'hello')
    assert(res.value is None)

    res = await hb.put(b'skipval', None)
    res = await hb.get(b'skipval')
    assert(res.value is None)
",
        storage_dir.path().display()
    );

    let output = run_python(&code)?;
    dbg!(&output);
    assert_eq!(output.status.code(), Some(0));
    Ok(())
}
#[tokio::test]
async fn check_version() -> Result<()> {
    let _x = require_python()?;
    let out = run_python(
        "
async def main():
    hb = await hyperbee_from_ram()
    x = await hb.version()
    assert(x == 0)
    await hb.put(b'foo', None)
    x = await hb.version()
    assert(x == 2)
",
    )?;
    assert_eq!(out.status.code(), Some(0));
    Ok(())
}

#[tokio::test]
async fn zero_to_one_hundred() -> Result<()> {
    let _x = require_python()?;
    let storage_dir = tempfile::tempdir()?;
    let hb = Hyperbee::from_storage_dir(&storage_dir).await?;
    let keys = write_range_to_hb!(&hb);
    let code = format!(
        "
async def main():
    import json
    hb = await hyperbee_from_storage_dir('{}')
    keys = [bytes(str(i), 'utf8') for i in range(100)]
    results = [await hb.get(k) for k in keys]
    values = [res.value.decode('utf8') for res in results]
    print(json.dumps(values))
",
        storage_dir.path().display()
    );

    let output = run_python(&code)?;
    let res = parse_json_result(&output)?;
    assert_eq!(res, keys);
    assert_eq!(output.status.code(), Some(0));
    Ok(())
}