bytecon_data_store 0.1.0

A library for storing ByteConverter implementations conveniently.
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

#[cfg(test)]
#[cfg(feature = "directory")]
mod directory_tests {
    use std::path::PathBuf;
    use bytecon_data_store::{implementation::directory::DirectoryDataStore, DataStore};
    use rand::{seq::SliceRandom, SeedableRng};
    use tempfile::NamedTempFile;

    #[test]
    fn test_k6u9_initialize() {
        let sqlite_tempfile = NamedTempFile::new().unwrap();
        let sqlite_file_path: PathBuf = sqlite_tempfile.path().into();
        let cache_filename_length: usize = 10;
        
        let _directory_data_store = DirectoryDataStore::new(
            sqlite_file_path,
            cache_filename_length,
        ).expect("Failed to create new DirectoryDataStore.");
    }

    #[tokio::test]
    async fn test_w2m7_initialize_and_then_initialize_instance() {
        let sqlite_tempfile = NamedTempFile::new().unwrap();
        let sqlite_file_path: PathBuf = sqlite_tempfile.path().into();
        let cache_filename_length: usize = 10;
        
        let mut directory_data_store = DirectoryDataStore::new(
            sqlite_file_path,
            cache_filename_length,
        ).expect("Failed to create new DirectoryDataStore.");

        directory_data_store.initialize()
            .await
            .expect("Failed to initialize DirectoryDataStore.");
    }

    #[tokio::test]
    async fn test_p4n8_store_bytes_and_retrieve_bytes_and_delete_bytes() {

        // initialize DirectoryDataStore

        let sqlite_tempfile = NamedTempFile::new().unwrap();
        let sqlite_file_path: PathBuf = sqlite_tempfile.path().into();
        let cache_filename_length: usize = 10;
        
        let mut directory_data_store = DirectoryDataStore::new(
            sqlite_file_path,
            cache_filename_length,
        ).expect("Failed to create new DirectoryDataStore.");

        directory_data_store.initialize()
            .await
            .expect("Failed to initialize DirectoryDataStore.");

        let mut ids = Vec::new();

        for j in 0..100 {

            // store file

            let mut bytes = Vec::new();
            bytes.push(1 + j);
            bytes.push(2 + j);
            bytes.push(3 + j);
            bytes.push(4 + j);
            bytes.push(5 + j);
            bytes.push(6 + j);
            bytes.push(7 + j);
            bytes.push(8 + j);
            let id = directory_data_store.insert(bytes.clone())
                .await
                .expect("Failed to insert into DirectoryDataStore.");

            // pull out bytes

            let read_bytes = directory_data_store.get(&id)
                .await
                .expect("Failed to read from DirectoryDataStore.");

            assert_eq!(bytes.len(), read_bytes.len());
            for i in 0..bytes.len() {
                assert_eq!(bytes[i], read_bytes[i]);
            }

            ids.push(id);
        }

        let list = directory_data_store.list(1, 4, 2)
            .await
            .expect("Failed to get list of IDs");

        assert_eq!(4, list.len());
        assert_eq!(7, list[0]);
        assert_eq!(8, list[1]);
        assert_eq!(9, list[2]);
        assert_eq!(10, list[3]);

        let mut random = rand::rngs::StdRng::from_entropy();
        ids.shuffle(&mut random);

        for id in ids {
            directory_data_store.delete(&id)
                .await
                .expect(&format!("Failed to delete for ID {}", id));
        }
    }

    #[tokio::test]
    async fn test_q8b2_bulk_insert_and_bulk_get() {
        let sqlite_tempfile = NamedTempFile::new().unwrap();
        let sqlite_file_path: PathBuf = sqlite_tempfile.path().into();
        let cache_filename_length: usize = 10;
        
        let mut data_store = DirectoryDataStore::new(
            sqlite_file_path,
            cache_filename_length,
        ).expect("Failed to create new DirectoryDataStore.");

        data_store.initialize()
            .await
            .expect("Failed to initialize DirectoryDataStore.");

        let original_bytes_collection = vec![
            vec![1u8],
            vec![2u8, 3u8],
            vec![4u8, 5u8, 6u8],
        ];
        let ids = data_store.bulk_insert(original_bytes_collection.clone())
            .await
            .expect("Failed to perform bulk insert.");

        // try in the original ID order
        {
            let retrieved_bytes_collection = data_store.bulk_get(&ids)
                .await
                .expect("Failed to bulk get by IDs.");

            assert_eq!(original_bytes_collection, retrieved_bytes_collection);
        }

        // try in reverse order
        {
            let mut reversed_ids = Vec::with_capacity(ids.len());
            for i in ids.len() - 1..=0 {
                reversed_ids.push(ids[i]);
            }

            let retrieved_bytes_collection = data_store.bulk_get(&reversed_ids)
                .await
                .expect("Failed to bulk get by IDs.");

            assert_ne!(original_bytes_collection, retrieved_bytes_collection);

            for (top_down, down_up) in (ids.len() - 1..=0).zip(0..ids.len()) {
                assert_eq!(original_bytes_collection[down_up], retrieved_bytes_collection[top_down]);
            }
        }
    }
}