reduct-base 1.19.2

Base crate for ReductStore
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

// Copyright 2021-2026 ReductSoftware UG
// Licensed under the Apache License, Version 2.0

use crate::io::{BoxedReadRecord, ReadChunk, ReadRecord, RecordMeta};
use bytes::Bytes;
use std::io::{Read, Seek, SeekFrom};

/// A simple in-memory record that can be read in one chunk
#[derive(Debug)]
pub struct OneShotRecord {
    content: Option<Bytes>,
    meta: RecordMeta,
}

impl OneShotRecord {
    pub fn new(content: Bytes, meta: RecordMeta) -> Self {
        Self {
            content: Some(content),
            meta,
        }
    }

    pub fn boxed(content: Bytes, meta: RecordMeta) -> BoxedReadRecord {
        Box::new(Self::new(content, meta))
    }
}

impl Read for OneShotRecord {
    fn read(&mut self, _buf: &mut [u8]) -> std::io::Result<usize> {
        unimplemented!()
    }
}

impl Seek for OneShotRecord {
    fn seek(&mut self, _pos: SeekFrom) -> std::io::Result<u64> {
        unimplemented!()
    }
}

impl ReadRecord for OneShotRecord {
    fn read_chunk(&mut self) -> ReadChunk {
        match self.content.take() {
            Some(content) => Some(Ok(content)),
            None => None,
        }
    }

    fn meta(&self) -> &RecordMeta {
        &self.meta
    }

    fn meta_mut(&mut self) -> &mut RecordMeta {
        &mut self.meta
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use bytes::Bytes;
    use rstest::{fixture, rstest};
    use std::collections::HashMap;
    use std::io::{Seek, SeekFrom};

    #[rstest]
    fn test_read_chunk(mut record: BoxedReadRecord) {
        // First read_chunk should return the content
        let chunk = record.read_chunk();
        assert!(chunk.is_some());
        assert_eq!(chunk.unwrap().unwrap(), "Hello World");

        // Second read_chunk should return None
        let chunk = record.read_chunk();
        assert!(chunk.is_none());
    }

    #[rstest]
    fn test_meta(record: BoxedReadRecord, meta: RecordMeta) {
        assert_eq!(record.meta(), &meta);
    }

    #[rstest]
    fn test_meta_mut(mut record: BoxedReadRecord) {
        record.meta_mut().state = 1;
        assert_eq!(record.meta().state, 1);
    }

    #[rstest]
    #[should_panic(expected = "not implemented")]
    fn test_seek(mut record: BoxedReadRecord) {
        let _ = record.seek(SeekFrom::Start(5));
    }

    #[rstest]
    #[should_panic(expected = "not implemented")]
    fn test_read(mut record: BoxedReadRecord) {
        let mut buf = [0; 5];
        let _ = record.read(&mut buf);
    }

    #[fixture]
    fn meta() -> RecordMeta {
        RecordMeta {
            entry_name: "entry".to_string(),
            timestamp: 0,
            state: 0,
            labels: HashMap::new(),
            content_type: "application/octet-stream".to_string(),
            content_length: 11,
            computed_labels: HashMap::new(),
        }
    }

    #[fixture]
    fn record(meta: RecordMeta) -> BoxedReadRecord {
        let content = Bytes::from("Hello World");
        OneShotRecord::boxed(content, meta)
    }
}