refactor(common): move assert tools to new test::assert module

Author: Alenar

mithril-common/src/test/dir_eq.rs renamed to mithril-common/src/test/assert/dir_eq.rs

@@ -0,0 +1,71 @@
+/// Compare two iterators ignoring the order
+pub fn equivalent_to<T, I1, I2>(a: I1, b: I2) -> bool
+where
+    T: PartialEq + Ord,
+    I1: IntoIterator<Item = T> + Clone,
+    I2: IntoIterator<Item = T> + Clone,
+{
+    let a = as_sorted_vec(a);
+    let b = as_sorted_vec(b);
+    a == b
+}
+
+/// Assert that two iterators are equivalent
+pub fn assert_equivalent<T, I1, I2>(a: I1, b: I2)
+where
+    T: PartialEq + Ord + std::fmt::Debug,
+    I1: IntoIterator<Item = T> + Clone,
+    I2: IntoIterator<Item = T> + Clone,
+{
+    let a = as_sorted_vec(a);
+    let b = as_sorted_vec(b);
+    assert_eq!(a, b);
+}
+
+/// Assert that two iterators are equivalent
+#[macro_export]
+macro_rules! assert_equivalent_macro {
+    ( $expected:expr, $actual:expr ) => {{
+        let expected = $crate::test::as_sorted_vec($expected);
+        let actual = $crate::test::as_sorted_vec($actual);
+        assert_eq!(expected, actual);
+    }};
+}
+pub use assert_equivalent_macro;
+
+/// Create a sorted clone of an iterable.
+pub fn as_sorted_vec<T: Ord, I: IntoIterator<Item = T> + Clone>(iter: I) -> Vec<T> {
+    let mut list: Vec<T> = iter.clone().into_iter().collect();
+    list.sort();
+    list
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashSet;
+
+    use super::*;
+
+    #[test]
+    fn test_equivalent_to() {
+        assert!(equivalent_to(vec![1, 2, 3], vec![3, 2, 1]));
+        assert!(equivalent_to(vec![1, 2, 3], vec![2, 1, 3]));
+        assert!(!equivalent_to(vec![1, 2, 3], vec![3, 2, 1, 4]));
+        assert!(!equivalent_to(vec![1, 2, 3], vec![3, 2]));
+
+        assert!(equivalent_to([1, 2, 3], vec![3, 2, 1]));
+        assert!(equivalent_to(&[1, 2, 3], &vec![3, 2, 1]));
+        assert!(equivalent_to([1, 2, 3], HashSet::from([3, 2, 1])));
+        assert!(equivalent_to(vec![1, 2, 3], HashSet::from([3, 2, 1])));
+        assert!(equivalent_to(&vec![1, 2, 3], &HashSet::from([3, 2, 1])));
+
+        assert_equivalent(vec![1, 2, 3], vec![3, 2, 1]);
+        assert_equivalent(vec![1, 2, 3], vec![2, 1, 3]);
+
+        assert_equivalent([1, 2, 3], vec![3, 2, 1]);
+        assert_equivalent(&[1, 2, 3], &vec![3, 2, 1]);
+        assert_equivalent([1, 2, 3], HashSet::from([3, 2, 1]));
+        assert_equivalent(vec![1, 2, 3], HashSet::from([3, 2, 1]));
+        assert_equivalent(&vec![1, 2, 3], &HashSet::from([3, 2, 1]));
+    }
+}

mithril-common/src/test/assert/iters_equivalent.rs

@@ -0,0 +1,11 @@
+/// Compare two json strings ignoring keys order
+#[macro_export]
+macro_rules! assert_same_json {
+    ( $expected:expr, $actual:expr ) => {
+        assert_eq!(
+            serde_json::from_str::<serde_json::Value>($expected).unwrap(),
+            serde_json::from_str::<serde_json::Value>($actual).unwrap()
+        )
+    };
+}
+pub use assert_same_json;

mithril-common/src/test/assert/json.rs

@@ -0,0 +1,7 @@
+mod dir_eq;
+mod iters_equivalent;
+mod json;
+
+pub use dir_eq::*;
+pub use iters_equivalent::*;
+pub use json::*;

mithril-common/src/test/assert/mod.rs

@@ -10,70 +10,16 @@ pub mod builder;
 pub mod double;
 pub mod mock_extensions;
 
-mod dir_eq;
+mod assert;
 mod memory_logger;
 mod temp_dir;
 
-pub use dir_eq::*;
+pub use assert::*;
 pub use memory_logger::*;
 pub use temp_dir::*;
 #[cfg(test)]
 pub(crate) use utils::*;
 
-/// Compare two json strings ignoring keys order
-#[macro_export]
-macro_rules! assert_same_json {
-    ( $expected:expr, $actual:expr ) => {
-        assert_eq!(
-            serde_json::from_str::<serde_json::Value>($expected).unwrap(),
-            serde_json::from_str::<serde_json::Value>($actual).unwrap()
-        )
-    };
-}
-pub use assert_same_json;
-
-/// Compare two iterators ignoring the order
-pub fn equivalent_to<T, I1, I2>(a: I1, b: I2) -> bool
-where
-    T: PartialEq + Ord,
-    I1: IntoIterator<Item = T> + Clone,
-    I2: IntoIterator<Item = T> + Clone,
-{
-    let a = as_sorted_vec(a);
-    let b = as_sorted_vec(b);
-    a == b
-}
-
-/// Assert that two iterators are equivalent
-pub fn assert_equivalent<T, I1, I2>(a: I1, b: I2)
-where
-    T: PartialEq + Ord + std::fmt::Debug,
-    I1: IntoIterator<Item = T> + Clone,
-    I2: IntoIterator<Item = T> + Clone,
-{
-    let a = as_sorted_vec(a);
-    let b = as_sorted_vec(b);
-    assert_eq!(a, b);
-}
-
-/// Assert that two iterators are equivalent
-#[macro_export]
-macro_rules! assert_equivalent_macro {
-    ( $expected:expr, $actual:expr ) => {{
-        let expected = $crate::test::as_sorted_vec($expected);
-        let actual = $crate::test::as_sorted_vec($actual);
-        assert_eq!(expected, actual);
-    }};
-}
-pub use assert_equivalent_macro;
-
-/// Create a sorted clone af an iterable.
-pub fn as_sorted_vec<T: Ord, I: IntoIterator<Item = T> + Clone>(iter: I) -> Vec<T> {
-    let mut list: Vec<T> = iter.clone().into_iter().collect();
-    list.sort();
-    list
-}
-
 /// Return the path of the given function.
 /// If the last function is `f`, it is removed.
 /// The last `{{closure}}` is also removed.
@@ -121,8 +67,8 @@ pub use current_function_path;
 #[cfg(test)]
 mod utils {
     use std::io;
+    use std::path::Path;
     use std::sync::Arc;
-    use std::{collections::HashSet, path::Path};
 
     use slog::{Drain, Logger};
     use slog_async::Async;
@@ -151,29 +97,6 @@ mod utils {
         }
     }
 
-    #[test]
-    fn test_equivalent_to() {
-        assert!(equivalent_to(vec![1, 2, 3], vec![3, 2, 1]));
-        assert!(equivalent_to(vec![1, 2, 3], vec![2, 1, 3]));
-        assert!(!equivalent_to(vec![1, 2, 3], vec![3, 2, 1, 4]));
-        assert!(!equivalent_to(vec![1, 2, 3], vec![3, 2]));
-
-        assert!(equivalent_to([1, 2, 3], vec![3, 2, 1]));
-        assert!(equivalent_to(&[1, 2, 3], &vec![3, 2, 1]));
-        assert!(equivalent_to([1, 2, 3], HashSet::from([3, 2, 1])));
-        assert!(equivalent_to(vec![1, 2, 3], HashSet::from([3, 2, 1])));
-        assert!(equivalent_to(&vec![1, 2, 3], &HashSet::from([3, 2, 1])));
-
-        assert_equivalent(vec![1, 2, 3], vec![3, 2, 1]);
-        assert_equivalent(vec![1, 2, 3], vec![2, 1, 3]);
-
-        assert_equivalent([1, 2, 3], vec![3, 2, 1]);
-        assert_equivalent(&[1, 2, 3], &vec![3, 2, 1]);
-        assert_equivalent([1, 2, 3], HashSet::from([3, 2, 1]));
-        assert_equivalent(vec![1, 2, 3], HashSet::from([3, 2, 1]));
-        assert_equivalent(&vec![1, 2, 3], &HashSet::from([3, 2, 1]));
-    }
-
     #[test]
     fn test_current_function_extract_function_name() {
         let name = current_function!();