bpm_core 0.1.0

Cross-platform software helping to verify, prove and secure package compilation, building, fetching, and deployment. Core package.
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

use super::blockchain_document::BlockchainDocument;

#[derive(Debug)]
pub struct BlockchainDocumentBuilder {
    label: Option<String>,
    last_synchronization: Option<String>,
}

impl BlockchainDocumentBuilder {
    /**
     * Set label
     */
    pub fn set_label(&mut self, label: String) -> &mut Self {
        self.label = Some(label);

        self
    }

    /**
     * Set blockchain last synchronization
     */
    pub fn set_last_synchronization(&mut self, timestamp: String) -> &mut Self {
        self.last_synchronization = Some(timestamp);

        self
    }

    /**
     * Reset builder
     */
    pub fn reset(&mut self) -> &mut Self {
        self.label = None;
        self.last_synchronization = None;

        self
    }

    /**
     * Build from document
     */
    pub fn from_document(doc: &BlockchainDocument) -> Self {
        let instance = Self {
            label: Some(doc.label.clone()),
            last_synchronization: Some(doc.last_synchronization.clone()),
        };

        instance
    }

    /**
     * Build document
     */
    pub fn build(&mut self) -> BlockchainDocument {
        let doc = BlockchainDocument {
            label: self.label.clone().expect("Label must be set"),
            last_synchronization: self
                .last_synchronization
                .clone()
                .expect("Last synchronization must be set"),
        };

        self.reset();

        doc
    }
}

impl Default for BlockchainDocumentBuilder {
    fn default() -> Self {
        let instance = Self {
            label: None,
            last_synchronization: None,
        };

        instance
    }
}

mod tests {

    use super::*;

    #[test]
    fn test_blockchain_build() {
        let mut builder = BlockchainDocumentBuilder::default();

        let expected_label = "hedera";
        let expected_last_synchronization = "1704067200";

        let doc = builder
            .set_label(expected_label.to_string())
            .set_last_synchronization(expected_last_synchronization.to_string())
            .build();

        assert_eq!(doc.label, expected_label);
        assert_eq!(doc.last_synchronization, expected_last_synchronization);
    }

    #[test]
    fn test_blockchain_reset() {
        let mut builder = BlockchainDocumentBuilder::default();

        let expected_label = "hedera";
        let expected_last_synchronization = "1704067200";

        let doc = builder
            .set_label(expected_label.to_string())
            .set_last_synchronization(expected_last_synchronization.to_string())
            .reset();

        assert_eq!(doc.label, None);
        assert_eq!(doc.last_synchronization, None);
    }

    #[test]
    fn test_blockchain_build_from_document() {
        let mut builder = BlockchainDocumentBuilder::default();

        let label_mock = "hedera";
        let last_sync_mock = "1704067200";

        let doc = builder
            .set_label(label_mock.to_string())
            .set_last_synchronization(last_sync_mock.to_string())
            .build();

        let new_doc = BlockchainDocumentBuilder::from_document(&doc).build();

        assert_eq!(new_doc.label, doc.label);
        assert_eq!(new_doc.last_synchronization, doc.last_synchronization);
    }
}