module separation

Migorithm · Migorithm · commit 388139bf050f · 2025-04-07T23:16:49.000+09:00
diff --git a/duva/tests/client_ops/mod.rs b/duva/tests/client_ops/mod.rs
@@ -0,0 +1,8 @@
+mod test_config_get_dir;
+mod test_del;
+mod test_exists;
+mod test_idempotent_client;
+mod test_keys;
+mod test_replication_info;
+mod test_set_get;
+mod test_snapshot_persists_and_recovers_state;
diff --git a/duva/tests/client_ops/test_config_get_dir.rs b/duva/tests/client_ops/test_config_get_dir.rs
@@ -1,13 +1,12 @@
 /// if the value of dir is /tmp, then the expected response to CONFIG GET dir is:
 /// *2\r\n$3\r\ndir\r\n$4\r\n/tmp\r\n
-mod common;
 use std::time::Duration;
 
-use crate::common::array;
-use common::{ServerEnv, spawn_server_process};
 use duva::clients::ClientStreamHandler;
 use tokio::time::sleep;
 
+use crate::common::{ServerEnv, array, spawn_server_process};
+
 #[tokio::test]
 async fn test_config_get_dir() {
     // GIVEN
diff --git a/duva/tests/client_ops/test_del.rs b/duva/tests/client_ops/test_del.rs
@@ -2,11 +2,9 @@
 /// Firstly, we set a key with a value and an expiry of 300ms
 /// Then we get the key and check if the value is returned
 /// After 300ms, we get the key again and check if the value is not returned (-1)
-mod common;
-use common::{ServerEnv, array, spawn_server_process};
-
 use duva::{clients::ClientStreamHandler, domains::query_parsers::query_io::QueryIO};
 
+use crate::common::{ServerEnv, array, spawn_server_process};
 #[tokio::test]
 async fn test_del() {
     // GIVEN
diff --git a/duva/tests/client_ops/test_exists.rs b/duva/tests/client_ops/test_exists.rs
@@ -2,11 +2,9 @@
 /// Firstly, we set a key with a value and an expiry of 300ms
 /// Then we get the key and check if the value is returned
 /// After 300ms, we get the key again and check if the value is not returned (-1)
-mod common;
-use common::{ServerEnv, array, spawn_server_process};
-
 use duva::{clients::ClientStreamHandler, domains::query_parsers::query_io::QueryIO};
 
+use crate::common::{ServerEnv, array, spawn_server_process};
 #[tokio::test]
 async fn test_exists() {
     // GIVEN
diff --git a/duva/tests/client_ops/test_idempotent_client.rs b/duva/tests/client_ops/test_idempotent_client.rs
@@ -1,7 +1,7 @@
-mod common;
-use common::{ServerEnv, array, session_request, spawn_server_process};
 use duva::{clients::ClientStreamHandler, domains::query_parsers::query_io::QueryIO};
 
+use crate::common::{ServerEnv, array, session_request, spawn_server_process};
+
 #[tokio::test]
 async fn test_send_session_request() {
     // GIVEN
diff --git a/duva/tests/client_ops/test_keys.rs b/duva/tests/client_ops/test_keys.rs
@@ -1,5 +1,4 @@
-mod common;
-use common::{ServerEnv, array, spawn_server_process};
+use crate::common::{ServerEnv, array, spawn_server_process};
 use duva::{clients::ClientStreamHandler, domains::query_parsers::query_io::QueryIO};
 
 #[tokio::test]
diff --git a/duva/tests/client_ops/test_replication_info.rs b/duva/tests/client_ops/test_replication_info.rs
@@ -3,9 +3,7 @@
 
 /// if the value of dir is /tmp, then the expected response to CONFIG GET dir is:
 /// *2\r\n$3\r\ndir\r\n$4\r\n/tmp\r\n
-mod common;
-
-use common::{ServerEnv, array, spawn_server_process};
+use crate::common::{ServerEnv, array, spawn_server_process};
 
 use duva::clients::ClientStreamHandler;
 
diff --git a/duva/tests/client_ops/test_set_get.rs b/duva/tests/client_ops/test_set_get.rs
@@ -2,9 +2,7 @@
 /// Firstly, we set a key with a value and an expiry of 300ms
 /// Then we get the key and check if the value is returned
 /// After 300ms, we get the key again and check if the value is not returned (-1)
-mod common;
-use common::{ServerEnv, array, spawn_server_process};
-
+use crate::common::{ServerEnv, array, spawn_server_process};
 use duva::{clients::ClientStreamHandler, domains::query_parsers::query_io::QueryIO};
 
 #[tokio::test]
diff --git a/duva/tests/client_ops/test_snapshot_persists_and_recovers_state.rs b/duva/tests/client_ops/test_snapshot_persists_and_recovers_state.rs
@@ -1,20 +1,13 @@
-/// Cache config should be injected to the handler!
-/// This is to enable client to configure things dynamically.
-
-/// if the value of dir is /tmp, then the expected response to CONFIG GET dir is:
-/// *2\r\n$3\r\ndir\r\n$4\r\n/tmp\r\n
-mod common;
-use crate::common::array;
-use common::ServerEnv;
-use common::spawn_server_process;
+use crate::common::{ServerEnv, array, spawn_server_process};
+
 use duva::clients::ClientStreamHandler;
 use duva::domains::query_parsers::query_io::QueryIO;
 use std::time::SystemTime;
 use std::time::UNIX_EPOCH;
 
 // TODO response cannot be deterministic!
 #[tokio::test]
-async fn test_save_read_snapshot() {
+async fn test_snapshot_persists_and_recovers_state() {
     // GIVEN
     let env = ServerEnv::default().with_file_name(create_unique_file_name("test_save_dump"));
     let leader_process = spawn_server_process(&env);
@@ -38,39 +31,31 @@ async fn test_save_read_snapshot() {
     // check replication info
     let res = h.send_and_get(&array(vec!["INFO", "replication"])).await;
     let info: Vec<&str> = res.split("\r\n").collect();
-    let prev_leader_repl_id = info[3].split(":").collect::<Vec<&str>>()[1];
-    let prev_leader_repl_offset = info[4].split(":").collect::<Vec<&str>>()[1];
 
-    // THEN
+    // WHEN
     assert_eq!(h.send_and_get(&array(vec!["SAVE"])).await, QueryIO::Null.serialize());
 
     // wait for the file to be created
     tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-
-    // THEN
     // kill leader process
     drop(leader_process);
 
     // run server with the same file name
-    let leader_process = spawn_server_process(&env);
+    let new_process = spawn_server_process(&env);
 
     // wait for the server to start
     tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
 
-    let mut h = ClientStreamHandler::new(leader_process.bind_addr()).await;
+    let mut client = ClientStreamHandler::new(new_process.bind_addr()).await;
 
-    // keys
-    assert_eq!(h.send_and_get(&array(vec!["KEYS", "*"])).await, array(vec!["foo2", "foo"]));
+    assert_eq!(client.send_and_get(&array(vec!["KEYS", "*"])).await, array(vec!["foo2", "foo"]));
 
     // replication info
-    let res = h.send_and_get(&array(vec!["INFO", "replication"])).await;
-    let info: Vec<&str> = res.split("\r\n").collect();
-    let leader_repl_id = info[3].split(":").collect::<Vec<&str>>()[1];
-    let leader_repl_offset = info[4].split(":").collect::<Vec<&str>>()[1];
+    let res = client.send_and_get(&array(vec!["INFO", "replication"])).await;
+    let info2: Vec<&str> = res.split("\r\n").collect();
 
     // THEN
-    assert_eq!(leader_repl_id, prev_leader_repl_id);
-    assert_eq!(leader_repl_offset, prev_leader_repl_offset);
+    assert_eq!(info, info2);
 }
 
 fn create_unique_file_name(function_name: &str) -> String {
diff --git a/duva/tests/cluster_ops/mod.rs b/duva/tests/cluster_ops/mod.rs
@@ -0,0 +1,6 @@
+mod test_cluster_forget_makes_all_nodes_forget_target_node;
+mod test_cluster_forget_when_wrong_id_given;
+mod test_cluster_known_nodes_increase_when_new_replica_is_added;
+mod test_disseminate_peers;
+mod test_heartbeat;
+mod test_removes_node_when_heartbeat_is_not_received_for_certain_time;
diff --git a/duva/tests/cluster_ops/test_cluster_forget_makes_all_nodes_forget_target_node.rs b/duva/tests/cluster_ops/test_cluster_forget_makes_all_nodes_forget_target_node.rs
@@ -1,5 +1,5 @@
-mod common;
-use common::{ServerEnv, array, check_internodes_communication, spawn_server_process};
+use crate::common::{ServerEnv, array, check_internodes_communication, spawn_server_process};
+
 use duva::{clients::ClientStreamHandler, domains::query_parsers::query_io::QueryIO};
 
 #[tokio::test]
diff --git a/duva/tests/cluster_ops/test_cluster_forget_when_wrong_id_given.rs b/duva/tests/cluster_ops/test_cluster_forget_when_wrong_id_given.rs
@@ -1,7 +1,6 @@
 /// Cluster forget {node id} is used in order to remove a node, from the set of known nodes for the node receiving the command.
 /// In other words the specified node is removed from the nodes table of the node receiving the command.
-mod common;
-use common::{ServerEnv, array, spawn_server_process};
+use crate::common::{ServerEnv, array, spawn_server_process};
 use duva::{clients::ClientStreamHandler, domains::query_parsers::query_io::QueryIO};
 
 #[tokio::test]
diff --git a/duva/tests/cluster_ops/test_cluster_known_nodes_increase_when_new_replica_is_added.rs b/duva/tests/cluster_ops/test_cluster_known_nodes_increase_when_new_replica_is_added.rs
@@ -1,5 +1,4 @@
-mod common;
-use common::{ServerEnv, array, spawn_server_process};
+use crate::common::{ServerEnv, array, spawn_server_process};
 use duva::{clients::ClientStreamHandler, domains::query_parsers::query_io::QueryIO};
 
 #[tokio::test]
diff --git a/duva/tests/cluster_ops/test_disseminate_peers.rs b/duva/tests/cluster_ops/test_disseminate_peers.rs
@@ -1,6 +1,5 @@
 /// After three-way handshake, client will receive peers from the leader server
-mod common;
-use common::{ServerEnv, spawn_server_process};
+use crate::common::{ServerEnv, spawn_server_process};
 
 #[tokio::test]
 async fn test_disseminate_peers() {
diff --git a/duva/tests/cluster_ops/test_heartbeat.rs b/duva/tests/cluster_ops/test_heartbeat.rs
@@ -1,9 +1,7 @@
 //! This file contains tests for heartbeat between leader and follower
 //! Any interconnected system should have a heartbeat mechanism to ensure that the connection is still alive
 //! In this case, the server will send PING message to the follower and the follower will respond with PONG message
-mod common;
-use common::{ServerEnv, check_internodes_communication, spawn_server_process};
-
+use crate::common::{ServerEnv, check_internodes_communication, spawn_server_process};
 #[tokio::test]
 async fn test_heartbeat_hop_count_decreases_over_time() {
     const DEFAULT_HOP_COUNT: usize = 0;
diff --git a/duva/tests/cluster_ops/test_removes_node_when_heartbeat_is_not_received_for_certain_time.rs b/duva/tests/cluster_ops/test_removes_node_when_heartbeat_is_not_received_for_certain_time.rs
@@ -1,5 +1,4 @@
-mod common;
-use common::{ServerEnv, array, spawn_server_process};
+use crate::common::{ServerEnv, array, spawn_server_process};
 use duva::{clients::ClientStreamHandler, domains::query_parsers::query_io::QueryIO};
 
 #[tokio::test]
diff --git a/duva/tests/common.rs b/duva/tests/common.rs
@@ -1,4 +1,5 @@
 #![allow(dead_code, unused_variables)]
+
 use bytes::Bytes;
 use duva::domains::query_parsers::query_io::QueryIO;
 use duva::make_smart_pointer;
diff --git a/duva/tests/replication_ops/mod.rs b/duva/tests/replication_ops/mod.rs
@@ -0,0 +1,3 @@
+mod test_leader_election;
+mod test_raft_happy_case;
+mod test_sync;
diff --git a/duva/tests/replication_ops/test_leader_election.rs b/duva/tests/replication_ops/test_leader_election.rs
@@ -1,7 +1,6 @@
-mod common;
 use std::{thread::sleep, time::Duration};
 
-use common::{ServerEnv, array, check_internodes_communication, spawn_server_process};
+use crate::common::{ServerEnv, array, check_internodes_communication, spawn_server_process};
 use duva::clients::ClientStreamHandler;
 
 #[tokio::test]
diff --git a/duva/tests/replication_ops/test_raft_happy_case.rs b/duva/tests/replication_ops/test_raft_happy_case.rs
@@ -1,5 +1,4 @@
-mod common;
-use common::{ServerEnv, spawn_server_process};
+use crate::common::{ServerEnv, array, spawn_server_process};
 use duva::clients::ClientStreamHandler;
 
 #[tokio::test]
@@ -21,7 +20,7 @@ async fn test_set_operation_reaches_to_all_replicas() {
     leader_p.wait_for_message(&repl_p.heartbeat_msg(0), 1).unwrap();
 
     // WHEN -- set operation is made
-    client_handler.send(&common::array(vec!["SET", "foo", "bar"])).await;
+    client_handler.send(&array(vec!["SET", "foo", "bar"])).await;
 
     //THEN - run the following together
     let h = std::thread::spawn(move || {
diff --git a/duva/tests/replication_ops/test_sync.rs b/duva/tests/replication_ops/test_sync.rs
@@ -1,6 +1,4 @@
-mod common;
-use crate::common::array;
-use common::{ServerEnv, check_internodes_communication, spawn_server_process};
+use crate::common::{ServerEnv, array, check_internodes_communication, spawn_server_process};
 use duva::clients::ClientStreamHandler;
 
 #[tokio::test]
@@ -20,7 +18,6 @@ async fn test_full_sync_on_newly_added_replica() {
     check_internodes_communication(&mut [&mut leader_p, &mut replica_process], 0, 1000).unwrap();
 
     // THEN
-
     let mut client_to_repl = ClientStreamHandler::new(replica_process.bind_addr()).await;
     assert_eq!(client_to_repl.send_and_get(&array(vec!["KEYS", "*"])).await, array(vec!["foo"]));
 }
diff --git a/duva/tests/test_mods.rs b/duva/tests/test_mods.rs
@@ -0,0 +1,5 @@
+mod client_ops;
+mod cluster_ops;
+mod replication_ops;
+
+mod common;
