added more tests

src/datastore.rs

@@ -290,7 +290,7 @@ mod tests {
     use std::time::{SystemTime, UNIX_EPOCH};
 
     #[test]
-    fn test_node_info_creation() {
+    fn node_info_creation() {
         let keypair = SigningKey::generate(&mut OsRng);
         let node_info = NodeInfo {
             pubkey: keypair.verifying_key(),
@@ -304,7 +304,7 @@ mod tests {
     }
 
     #[test]
-    fn test_store_creation() {
+    fn store_creation() {
         let store = Store {
             nodes: DashMap::new(),
             conns: DashSet::new(),
@@ -317,7 +317,7 @@ mod tests {
     }
 
     #[test]
-    fn test_signing_error_from_hex_error() {
+    fn signing_error_from_hex_error() {
         let hex_error: Result<(), hex::FromHexError> =
             Err(hex::FromHexError::InvalidHexCharacter { c: 'a', index: 0 });
         let signing_error: SigningError = hex_error.unwrap_err().into();
@@ -329,7 +329,7 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_sign_message_with_key() {
+    async fn sign_message_with_key() {
         let keypair = SigningKey::generate(&mut OsRng);
         let pubkey_hex = hex::encode(keypair.verifying_key().as_bytes());
         let store = Store {
@@ -349,7 +349,7 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_process_node_update() {
+    async fn process_node_update() {
         let keypair = SigningKey::generate(&mut OsRng);
         let node_update = NodeUpdate {
             ip: "127.0.0.1".to_string(),
@@ -377,7 +377,7 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_get_full_node_list() {
+    async fn get_full_node_list() {
         let keypair = SigningKey::generate(&mut OsRng);
         let node_info = NodeInfo {
             pubkey: keypair.verifying_key(),

src/persistence.rs

@@ -116,6 +116,7 @@ mod tests {
     use super::*;
     use ed25519_dalek::SigningKey;
     use rand::rngs::OsRng;
+    use rand::Rng;
     use std::io::Result;
     use tokio::fs::remove_file;
     use tokio::io::AsyncWriteExt;
@@ -125,6 +126,7 @@ mod tests {
         TEST_FILE_PREFIX.to_string() + function
     }
     async fn setup_test_file(function: &str) -> Result<FileManager> {
+        let _ = tokio::fs::create_dir_all(".tmp").await;
         let path = get_test_file_name(function);
         let mut file = File::create(path.clone()).await?;
         file.flush().await?;
@@ -133,7 +135,7 @@ mod tests {
     }
 
     #[test]
-    fn test_node_to_bytes_and_back() {
+    fn node_round_trip() {
         let keypair = SigningKey::generate(&mut OsRng);
 
         let original_node = Node {
@@ -166,36 +168,35 @@ mod tests {
 
     #[tokio::test]
     async fn setup_file_manager() {
-        match setup_test_file("setup_file_manager").await {
+        let function_name = "setup_file_manager";
+        let _ = match setup_test_file(function_name).await {
             Err(e) => {
                 panic!("Could not init File Manager: {}", e);
             }
-            _ => {}
+            _ => remove_file(get_test_file_name(function_name)).await,
+        };
+    }
+
+    fn get_random_node() -> Node {
+        let keypair = SigningKey::generate(&mut OsRng);
+        let mut rng = rand::thread_rng();
+        let ipv4 = Ipv4Addr::new(rng.gen(), rng.gen(), rng.gen(), rng.gen());
+        Node {
+            ip: ipv4,
+            keypair: keypair.clone(),
+            joined_at: SystemTime::now(),
         }
     }
 
     #[tokio::test]
-    async fn test_file_manager_append_and_retrieve_node() -> Result<()> {
+    async fn append_and_retrieve() -> Result<()> {
-        let function_name = "test_file_manager_append_and_retrieve_node";
+        let function_name = "append_and_retrieve";
         let manager = setup_test_file(function_name).await?;
-
+        let node = get_random_node();
-        let keypair = SigningKey::generate(&mut OsRng);
+        manager.append_node(node.clone()).await?;
-
+        let retrieved_node = manager.get_node_by_id(0).await?;
-        let node = Node {
-            ip: "192.168.1.1".parse().unwrap(),
-            keypair: keypair.clone(),
-            joined_at: SystemTime::now(),
-        };
-
-        manager.append_node(node.clone()).await.unwrap();
-
-        let retrieved_node = manager.get_node_by_id(0).await.unwrap();
-
         assert_eq!(node.ip_as_string(), retrieved_node.ip_as_string());
-        assert_eq!(
+        assert_eq!(node.keypair, retrieved_node.keypair);
-            node.keypair.to_keypair_bytes(),
-            retrieved_node.keypair.to_keypair_bytes()
-        );
         assert_eq!(
             node.joined_at.duration_since(UNIX_EPOCH).unwrap().as_secs(),
             retrieved_node
@@ -205,49 +206,85 @@ mod tests {
                 .as_secs()
         );
         remove_file(get_test_file_name(function_name)).await?;
-
         Ok(())
     }
 
     #[tokio::test]
-    async fn test_file_manager_multiple_nodes() -> Result<()> {
+    async fn append_and_retrieve_multiple() -> Result<()> {
-        let function_name = "test_file_manager_multiple_nodes";
+        let function_name = "append_and_retrieve_multiple";
         let manager = setup_test_file(function_name).await?;
-
+        let node1 = get_random_node();
-        let keypair1 = SigningKey::generate(&mut OsRng);
+        let node2 = get_random_node();
-        let node1 = Node {
+        manager.append_node(node1.clone()).await?;
-            ip: "192.168.1.1".parse().unwrap(),
+        manager.append_node(node2.clone()).await?;
-            keypair: keypair1.clone(),
-            joined_at: SystemTime::now(),
-        };
-
-        let keypair2 = SigningKey::generate(&mut OsRng);
-        let node2 = Node {
-            ip: "10.0.0.1".parse().unwrap(),
-            keypair: keypair2.clone(),
-            joined_at: SystemTime::now(),
-        };
-
-        manager.append_node(node1.clone()).await.unwrap();
-        manager.append_node(node2.clone()).await.unwrap();
-
         let retrieved_node1 = manager.get_node_by_id(0).await?;
+        let node3 = get_random_node();
+        manager.append_node(node3.clone()).await.unwrap();
         let retrieved_node2 = manager.get_node_by_id(1).await?;
-
         assert_eq!(node1.ip_as_string(), retrieved_node1.ip_as_string());
         assert_eq!(
             node1.keypair.to_keypair_bytes(),
             retrieved_node1.keypair.to_keypair_bytes()
         );
-
         assert_eq!(node2.ip_as_string(), retrieved_node2.ip_as_string());
-        assert_eq!(
+        assert_eq!(node2.keypair, retrieved_node2.keypair);
-            node2.keypair.to_keypair_bytes(),
+        let retrieved_node3 = manager.get_node_by_id(2).await?;
-            retrieved_node2.keypair.to_keypair_bytes()
+        assert_eq!(node3.ip_as_string(), retrieved_node3.ip_as_string());
-        );
+        assert_eq!(node3.keypair, retrieved_node3.keypair);
+        remove_file(get_test_file_name(function_name)).await?;
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn append_20_and_retrieve_1_loop() -> Result<()> {
+        let function_name = "append_20_and_retrieve_1_loop";
+        let manager = setup_test_file(function_name).await?;
+        let mut count = 0;
+        let mut nodes_vec: Vec<Node> = Vec::new();
+        while count < 100 {
+            let node = get_random_node();
+            if count % 10 == 0 {
+                nodes_vec.push(node.clone());
+            }
+            manager.append_node(node).await?;
+
+            count += 1;
+        }
+
+        count = 0;
+        for node in nodes_vec.iter() {
+            let r_node = manager.get_node_by_id(count * 10).await?;
+            assert_eq!(node.ip_as_string(), r_node.ip_as_string());
+            assert_eq!(node.keypair, r_node.keypair);
+            count += 1;
+            if count > 3 {
+                break;
+            }
+        }
+
+        count = 100;
+        while count < 500 {
+            let node = get_random_node();
+            if count % 10 == 0 {
+                nodes_vec.push(node.clone());
+            }
+            manager.append_node(node).await?;
+
+            count += 1;
+        }
+
+        count = 0;
+        for node in nodes_vec.iter() {
+            let r_node = manager.get_node_by_id(count * 10).await?;
+            assert_eq!(node.ip_as_string(), r_node.ip_as_string());
+            assert_eq!(node.keypair, r_node.keypair);
+            count += 1;
+            if count > 49 {
+                break;
+            }
+        }
 
         remove_file(get_test_file_name(function_name)).await?;
-
         Ok(())
     }
 }