taubyte_sdk/storage/content/
open.rs

1use crate::errno::Error;
2
3use super::{imports, Content, ReadOnlyContent};
4use cid::Cid;
5
6impl Content {
7    fn open_unsafe(id: *mut u32, cid: Cid) -> Error {
8        let cid_bytes = cid.to_bytes();
9
10        #[allow(unused_unsafe)]
11        unsafe {
12            imports::storageOpenCid(id, cid_bytes.as_ptr())
13        }
14    }
15
16    pub fn open(cid: Cid) -> Result<ReadOnlyContent, Box<dyn std::error::Error>> {
17        let mut id: u32 = 0;
18        let err0 = Content::open_unsafe(&mut id, cid);
19        if err0.is_err() {
20            Err(format!("Opening content failed with: {}", err0).into())
21        } else {
22            Ok(ReadOnlyContent {
23                content: Content {
24                    id: id,
25                    consumed: false,
26                },
27            })
28        }
29    }
30}
31
32#[cfg(test)]
33pub mod test {
34    use crate::storage::content::new::test as new_test;
35    use crate::storage::Content;
36    use cid::Cid;
37    pub static CID: &str = "QmbRDNT7TiEKHdav4iZYjLj5Q5QB2BTkKwXeXV3xggQWCR";
38
39    #[test]
40    fn open() {
41        let cid = Cid::try_from(CID).unwrap_or_else(|err| {
42            panic!("{}", err);
43        });
44
45        let read_only = Content::open(cid).unwrap_or_else(|err| {
46            panic!("{}", err);
47        });
48
49        assert_eq!(read_only.content.id, new_test::ID);
50    }
51}
52
53#[cfg(test)]
54#[allow(non_snake_case)]
55pub mod mock {
56    use cid::Cid;
57
58    use crate::{
59        errno::{Errno, Error},
60        storage::content::new::test as new_test,
61        utils::test as utils,
62    };
63
64    pub fn storageOpenCid(id: *mut u32, cid_ptr: *const u8) -> Error {
65        use super::test;
66
67        let cid_bytes = utils::read_bytes(cid_ptr, 64);
68        let err = Cid::try_from(cid_bytes);
69        if err.is_err() {
70            return Errno::ErrorCap.error();
71        }
72        let cid = err.unwrap();
73
74        if cid.to_string() != test::CID {
75            Errno::ErrorCap.error()
76        } else {
77            utils::write_u32(id, new_test::ID);
78            Errno::ErrorNone.error()
79        }
80    }
81}