dpp/tests/utils/
mod.rs

1use anyhow::Result;
2use dashcore::block::Version;
3use dashcore::hashes::Hash;
4use dashcore::{Block, BlockHash, CompactTarget, Header, TxMerkleNode};
5use platform_value::Value;
6#[cfg(test)]
7use serde_json::Value as JsonValue;
8
9use crate::prelude::Identifier;
10
11#[cfg(test)]
12#[macro_export]
13macro_rules! assert_error_contains {
14    ($result:ident, $contains:expr) => {
15        match $result {
16            Ok(o) => {
17                panic!("expected error, but returned: {:?}", o);
18            }
19            Err(e) => {
20                let string_error = e.to_string();
21                if !string_error.contains($contains) {
22                    panic!(
23                        "assertion error: '{}' hasn't been found in '{}'",
24                        $contains, string_error
25                    );
26                }
27            }
28        }
29    };
30}
31
32/// Sets a key value pair in serde_json object, returns the modified object
33pub fn serde_set<T, S>(mut object: serde_json::Value, key: T, value: S) -> serde_json::Value
34where
35    T: Into<String>,
36    S: Into<serde_json::Value>,
37    serde_json::Value: From<S>,
38{
39    let map = object
40        .as_object_mut()
41        .expect("Expected value to be an JSON object");
42    map.insert(key.into(), serde_json::Value::from(value));
43
44    object
45}
46
47/// Sets a key value pair in serde_json object, returns the modified object
48pub fn platform_value_set_ref<T, S>(object: &mut Value, key: T, value: S)
49where
50    T: Into<Value>,
51    S: Into<Value>,
52    Value: From<S>,
53{
54    let map = object
55        .as_map_mut()
56        .expect("Expected value to be an JSON object");
57    map.push((key.into(), value.into()));
58}
59
60pub fn generate_random_identifier_struct() -> Identifier {
61    let mut buffer = [0u8; 32];
62    getrandom::getrandom(&mut buffer).unwrap();
63    Identifier::from_bytes(&buffer).unwrap()
64}
65
66pub fn get_data_from_file(file_path: &str) -> Result<String> {
67    let current_dir = std::env::current_dir()?;
68    let file_path = format!("{}/{}", current_dir.display(), file_path);
69    let d = std::fs::read_to_string(file_path)?;
70    Ok(d)
71}
72
73#[cfg(test)]
74pub trait SerdeTestExtension {
75    fn remove_key(&mut self, key: impl Into<String>);
76    fn set_key_value<T, S>(&mut self, key: T, value: S)
77    where
78        T: Into<String>,
79        S: Into<serde_json::Value>,
80        serde_json::Value: From<S>;
81    fn get_value(&self, key: impl Into<String>) -> &serde_json::Value;
82    fn get_value_mut(&mut self, key: impl Into<String>) -> &mut serde_json::Value;
83}
84
85#[cfg(test)]
86impl SerdeTestExtension for serde_json::Value {
87    fn remove_key(&mut self, key: impl Into<String>) {
88        self.as_object_mut()
89            .expect("Expected value to be an JSON object")
90            .remove(&key.into());
91    }
92
93    fn set_key_value<T, S>(&mut self, key: T, value: S)
94    where
95        T: Into<String>,
96        S: Into<JsonValue>,
97        JsonValue: From<S>,
98    {
99        let map = self
100            .as_object_mut()
101            .expect("Expected value to be an JSON object");
102        map.insert(key.into(), serde_json::Value::from(value));
103    }
104
105    fn get_value(&self, key: impl Into<String>) -> &JsonValue {
106        self.as_object()
107            .expect("Expected key to exist")
108            .get(&key.into())
109            .expect("Expected key to exist")
110    }
111
112    fn get_value_mut(&mut self, key: impl Into<String>) -> &mut JsonValue {
113        self.as_object_mut()
114            .expect("Expected key to exist")
115            .get_mut(&key.into())
116            .expect("Expected key to exist")
117    }
118}
119
120// fn byte_to_hex(byte: &u8) -> String {
121//     format!("{:02x}", byte)
122// }
123//
124// /// Serializes bytes into a hex string
125// pub fn encode_hex<T: Clone + Into<Vec<u8>>>(bytes: &T) -> String {
126//     let hex_vec: Vec<String> = bytes.clone().into().iter().map(byte_to_hex).collect();
127//
128//     hex_vec.join("")
129// }
130
131/// Assert that all validation error belong to a certain enum variant and
132/// extracts all the errors from enum to a vector
133#[macro_export]
134macro_rules! assert_consensus_errors {
135    ($validation_result: expr, $variant: path, $expected_errors_count: expr) => {{
136        if $validation_result.errors.len() != $expected_errors_count {
137            for error in $validation_result.errors.iter() {
138                println!("{:?}", error);
139            }
140        }
141
142        assert_eq!($validation_result.errors.len(), $expected_errors_count);
143
144        let mut errors = Vec::new();
145
146        for error in &$validation_result.errors {
147            match error {
148                $variant(err) => errors.push(err),
149                err => {
150                    panic!("Got error that differs from what was expected: {:?}", err)
151                }
152            }
153        }
154
155        errors
156    }};
157}
158
159/// Assert that all validation error belong to a certain enum variant of basic consensus errors
160/// and extracts all the errors from enum to a vector
161#[macro_export]
162macro_rules! assert_basic_consensus_errors {
163    ($validation_result: expr, $variant: path, $expected_errors_count: expr) => {{
164        if $validation_result.errors.len() != $expected_errors_count {
165            for error in $validation_result.errors.iter() {
166                println!("{:?}", error);
167            }
168        }
169
170        assert_eq!($validation_result.errors.len(), $expected_errors_count);
171
172        let mut errors = Vec::new();
173
174        for error in &$validation_result.errors {
175            match error {
176                ConsensusError::BasicError($variant(err)) => errors.push(err),
177                err => {
178                    panic!("Got error that differs from what was expected: {:?}", err)
179                }
180            }
181        }
182
183        errors
184    }};
185}
186
187/// Assert that all validation error belong to a certain enum variant of state consensus errors
188/// and extracts all the errors from enum to a vector
189#[macro_export]
190macro_rules! assert_state_consensus_errors {
191    ($validation_result: expr, $variant: path, $expected_errors_count: expr) => {{
192        if $validation_result.errors.len() != $expected_errors_count {
193            for error in $validation_result.errors.iter() {
194                println!("{:?}", error);
195            }
196        }
197
198        assert_eq!($validation_result.errors.len(), $expected_errors_count);
199
200        let mut errors = Vec::new();
201
202        for error in &$validation_result.errors {
203            match error {
204                ConsensusError::StateError($variant(err)) => errors.push(err),
205                err => {
206                    panic!("Got error that differs from what was expected: {:?}", err)
207                }
208            }
209        }
210
211        errors
212    }};
213}
214
215pub fn create_empty_block(timestamp_secs: Option<u32>) -> Block {
216    Block {
217        txdata: vec![],
218        header: new_block_header(timestamp_secs),
219    }
220}
221
222pub fn new_block_header(timestamp_secs: Option<u32>) -> Header {
223    Header {
224        bits: CompactTarget::default(),
225        nonce: 0,
226        merkle_root: TxMerkleNode::all_zeros(),
227        prev_blockhash: BlockHash::all_zeros(),
228        version: Version::default(),
229        time: timestamp_secs.unwrap_or_default(),
230    }
231}
dpp/tests/utils/mod.rs

dpp/tests/utils/
mod.rs
