tr1pd 0.3.1

tamper resistant audit log
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

use storage::{self, BlockStorage, Result};
use blocks::BlockPointer;

use pseudo::Mock;

use std::result;


#[derive(Debug, Clone)]
pub struct ClonableError;

impl Into<storage::Error> for ClonableError {
    fn into(self) -> storage::Error {
        format!("{:?}", self).into()
    }
}

pub struct MockStorage {
    pub write_bytes: Mock<(BlockPointer, Vec<u8>), result::Result<(), ClonableError>>,

    pub get_bytes: Mock<BlockPointer, result::Result<Vec<u8>, ClonableError>>,

    pub get_head: Mock<(), result::Result<BlockPointer, ClonableError>>,

    pub update_head: Mock<BlockPointer, result::Result<(), ClonableError>>,
}

impl MockStorage {
    pub fn new() -> MockStorage {
        MockStorage {
            write_bytes: Mock::new(Ok(())),
            get_bytes: Mock::new(Err(ClonableError)),
            get_head: Mock::new(Err(ClonableError)),
            update_head: Mock::new(Ok(())),
        }
    }
}

impl BlockStorage for MockStorage {
    fn write_bytes(&mut self, pointer: &BlockPointer, bytes: Vec<u8>) -> Result<()> {
        self.write_bytes.call((pointer.clone(), bytes)).map_err(|x| x.into())
    }

    fn get_bytes(&self, pointer: &BlockPointer) -> Result<Vec<u8>> {
        self.get_bytes.call(pointer.clone()).map_err(|x| x.into())
    }

    fn get_head(&self) -> Result<BlockPointer> {
        self.get_head.call(()).map_err(|x| x.into())
    }

    fn update_head(&mut self, pointer: &BlockPointer) -> Result<()> {
        self.update_head.call(pointer.clone()).map_err(|x| x.into())
    }
}