seperating tests

renamed a test file
seperated daemon service tests
modularizing test into reusable methods

tests/common/prepare_test_env.rs

@@ -92,6 +92,7 @@ pub async fn connect_stream_client_channel(c_stream: DuplexStream, addr: SocketA
         .unwrap()
 }
 
+#[allow(dead_code)]
 pub async fn run_service_for_stream() -> Channel {
     let (client, addr) = run_service_for_stream_server().await;
     connect_stream_client_channel(client, addr).await

tests/common/test_utils.rs

@@ -38,6 +38,7 @@ impl Key {
         Ok(bs58::encode(key.sign(message.as_bytes()).to_bytes()).into_string())
     }
 
+    #[allow(dead_code)]
     pub fn sign_stream_auth(&self, contracts: Vec<String>) -> Result<snp_proto::DaemonStreamAuth> {
         let pubkey = self.pubkey.clone();
         let timestamp = chrono::Utc::now().to_rfc3339();

tests/grpc_test.rs

@@ -0,0 +1,123 @@
+use common::{
+    prepare_test_env::{prepare_test_db, run_service_for_stream, run_service_in_background},
+    test_utils::Key,
+};
+use detee_shared::common_proto::Empty;
+use detee_shared::general_proto::ReportNodeReq;
+use detee_shared::vm_proto::brain_vm_cli_client::BrainVmCliClient;
+use detee_shared::vm_proto::ListVmContractsReq;
+use detee_shared::{
+    common_proto::Pubkey, general_proto::brain_general_cli_client::BrainGeneralCliClient,
+};
+use futures::StreamExt;
+
+mod common;
+
+#[tokio::test]
+async fn test_general_balance() {
+    // env_logger::builder().filter_level(log::LevelFilter::Trace).init();
+    let _ = prepare_test_db().await;
+
+    let addr = run_service_in_background().await;
+    let mut client = BrainGeneralCliClient::connect(format!("http://{}", addr)).await.unwrap();
+
+    let key = Key::new();
+    let pubkey = key.pubkey.clone();
+    let req_data = Pubkey { pubkey };
+
+    let req = key.sign_request(req_data).unwrap();
+
+    let acc_bal = client.get_balance(req).await.unwrap().into_inner();
+
+    assert_eq!(acc_bal.balance, 0);
+    assert_eq!(acc_bal.tmp_locked, 0);
+}
+
+#[tokio::test]
+async fn test_report_node() {
+    prepare_test_db().await;
+
+    let addr = run_service_in_background().await;
+    let mut client = BrainGeneralCliClient::connect(format!("http://{}", addr)).await.unwrap();
+
+    let key = Key::new();
+    let pubkey = key.pubkey.clone();
+
+    // TODO: create contract, node and operator in db and use it here
+    let req_data = ReportNodeReq {
+        admin_pubkey: pubkey,
+        node_pubkey: String::from("node_pubkey"),
+        contract: String::from("uuid"),
+        reason: String::from("reason"),
+    };
+
+    let report_error = client.report_node(key.sign_request(req_data).unwrap()).await.err().unwrap();
+
+    println!("Report error: {:?}", report_error);
+    assert_eq!(report_error.message(), "No contract found by this ID.");
+
+    // verify report in db
+}
+
+#[tokio::test]
+// TODO: register some operators before testing this
+async fn test_list_operators() {
+    prepare_test_db().await;
+
+    let channel = run_service_for_stream().await;
+
+    let mut client = BrainGeneralCliClient::new(channel);
+
+    let key = Key::new();
+
+    let mut grpc_stream =
+        client.list_operators(key.sign_request(Empty {}).unwrap()).await.unwrap().into_inner();
+
+    let mut operators = Vec::new();
+    while let Some(stream_update) = grpc_stream.next().await {
+        match stream_update {
+            Ok(op) => {
+                operators.push(op);
+            }
+            Err(e) => {
+                panic!("Received error instead of operators: {e:?}");
+            }
+        }
+    }
+
+    assert!(!operators.is_empty())
+}
+
+#[tokio::test]
+// TODO: create vm for this user before testing this
+async fn test_list_vm_contracts() {
+    prepare_test_db().await;
+
+    let channel = run_service_for_stream().await;
+    let mut client = BrainVmCliClient::new(channel);
+
+    let key = Key::new();
+    let pubkey = key.pubkey.clone();
+
+    let req_data =
+        ListVmContractsReq { wallet: pubkey, uuid: String::from("uuid"), as_operator: false };
+
+    let mut grpc_stream =
+        client.list_vm_contracts(key.sign_request(req_data).unwrap()).await.unwrap().into_inner();
+
+    let mut vm_contracts = Vec::new();
+    while let Some(stream_update) = grpc_stream.next().await {
+        match stream_update {
+            Ok(vm_c) => {
+                vm_contracts.push(vm_c);
+            }
+            Err(e) => {
+                panic!("Received error instead of vm_contracts: {e:?}");
+            }
+        }
+    }
+
+    assert!(vm_contracts.is_empty())
+
+    // verify report in db
+}

tests/grpc_vm_daemon_test.rs

@@ -1,32 +1,41 @@
-use detee_shared::common_proto::Empty;
+use common::{
-use detee_shared::general_proto::ReportNodeReq;
+    prepare_test_env::{
+        connect_stream_client_channel, prepare_test_db, run_service_for_stream_server,
+        run_service_in_background,
+    },
+    test_utils::Key,
+};
+use detee_shared::vm_proto;
 use detee_shared::vm_proto::brain_vm_cli_client::BrainVmCliClient;
 use detee_shared::vm_proto::brain_vm_daemon_client::BrainVmDaemonClient;
-use detee_shared::vm_proto::{ListVmContractsReq, RegisterVmNodeReq};
+use detee_shared::vm_proto::RegisterVmNodeReq;
-use detee_shared::{
-    common_proto::Pubkey, general_proto::brain_general_cli_client::BrainGeneralCliClient, vm_proto,
-};
-mod common;
-use common::prepare_test_env::{
-    connect_stream_client_channel, prepare_test_db, run_service_for_stream,
-    run_service_for_stream_server, run_service_in_background,
-};
-use common::test_utils::Key;
 use futures::StreamExt;
 use tokio::task::JoinSet;
 use tokio_stream::wrappers::ReceiverStream;
 
+mod common;
+
 #[tokio::test]
 async fn test_reg_vm_node() {
     prepare_test_db().await;
 
     let addr = run_service_in_background().await;
-    let mut client = BrainVmDaemonClient::connect(format!("http://{}", addr)).await.unwrap();
+    let client = BrainVmDaemonClient::connect(format!("http://{}", addr)).await.unwrap();
 
     let operator_wallet = Key::new().pubkey;
 
     let key = Key::new();
 
+    let vm_contracts = register_vm_node(client, key, operator_wallet).await;
+
+    assert!(vm_contracts.is_empty())
+}
+
+async fn register_vm_node(
+    mut client: BrainVmDaemonClient<tonic::transport::Channel>,
+    key: Key,
+    operator_wallet: String,
+) -> Vec<vm_proto::VmContract> {
     let node_pubkey = key.pubkey.clone();
 
     let req = RegisterVmNodeReq {
@@ -53,8 +62,7 @@ async fn test_reg_vm_node() {
             }
         }
     }
-
+    vm_contracts
-    assert!(vm_contracts.is_empty())
 }
 
 #[tokio::test]
@@ -66,8 +74,6 @@ async fn test_brain_message() {
     // validate if something happening in "surreal_brain::db::NewVmReq", "surreal_brain::db::UpdateVmReq", "surreal_brain::db::DeletedVm" these table
     // mock daemon will responde to brain
 
-    // TODO: register node before connecting to brain
-
     env_logger::builder().filter_level(log::LevelFilter::Info).init();
     let _ = prepare_test_db().await;
 
@@ -79,6 +85,8 @@ async fn test_brain_message() {
 
     let daemon_key = Key::new();
 
+    register_vm_node(daemon_client.clone(), daemon_key.clone(), Key::new().pubkey).await;
+
     let mut daemon_join_set = JoinSet::new();
 
     let (tx, mut brain_msg_rx) = tokio::sync::mpsc::channel(1);
@@ -142,10 +150,10 @@ async fn test_brain_message() {
                     daemon_msg_tx.send(res_data).await.unwrap();
                 }
                 Some(vm_proto::brain_vm_message::Msg::UpdateVmReq(_update_vm_req)) => {
-                    //
+                    todo!()
                 }
                 Some(vm_proto::brain_vm_message::Msg::DeleteVm(_del_vm_req)) => {
-                    //
+                    todo!()
                 }
                 None => todo!(),
             }
@@ -178,112 +186,3 @@ async fn test_brain_message() {
 
     assert_eq!(data_in_db, new_vm_resp.args.unwrap());
 }
-
-#[tokio::test]
-async fn test_general_balance() {
-    // env_logger::builder().filter_level(log::LevelFilter::Trace).init();
-    let _ = prepare_test_db().await;
-
-    let addr = run_service_in_background().await;
-    let mut client = BrainGeneralCliClient::connect(format!("http://{}", addr)).await.unwrap();
-
-    let key = Key::new();
-    let pubkey = key.pubkey.clone();
-    let req_data = Pubkey { pubkey };
-
-    let req = key.sign_request(req_data).unwrap();
-
-    let acc_bal = client.get_balance(req).await.unwrap().into_inner();
-
-    assert_eq!(acc_bal.balance, 0);
-    assert_eq!(acc_bal.tmp_locked, 0);
-}
-
-#[tokio::test]
-async fn test_report_node() {
-    prepare_test_db().await;
-
-    let addr = run_service_in_background().await;
-    let mut client = BrainGeneralCliClient::connect(format!("http://{}", addr)).await.unwrap();
-
-    let key = Key::new();
-    let pubkey = key.pubkey.clone();
-
-    // TODO: create contract, node and operator in db and use it here
-    let req_data = ReportNodeReq {
-        admin_pubkey: pubkey,
-        node_pubkey: String::from("node_pubkey"),
-        contract: String::from("uuid"),
-        reason: String::from("reason"),
-    };
-
-    let report_error = client.report_node(key.sign_request(req_data).unwrap()).await.err().unwrap();
-
-    println!("Report error: {:?}", report_error);
-    assert_eq!(report_error.message(), "No contract found by this ID.");
-
-    // verify report in db
-}
-
-#[tokio::test]
-// TODO: register some operators before testing this
-async fn test_list_operators() {
-    prepare_test_db().await;
-
-    let channel = run_service_for_stream().await;
-
-    let mut client = BrainGeneralCliClient::new(channel);
-
-    let key = Key::new();
-
-    let mut grpc_stream =
-        client.list_operators(key.sign_request(Empty {}).unwrap()).await.unwrap().into_inner();
-
-    let mut operators = Vec::new();
-    while let Some(stream_update) = grpc_stream.next().await {
-        match stream_update {
-            Ok(op) => {
-                operators.push(op);
-            }
-            Err(e) => {
-                panic!("Received error instead of operators: {e:?}");
-            }
-        }
-    }
-
-    assert!(!operators.is_empty())
-}
-
-#[tokio::test]
-// TODO: create vm for this user before testing this
-async fn test_list_vm_contracts() {
-    prepare_test_db().await;
-
-    let channel = run_service_for_stream().await;
-    let mut client = BrainVmCliClient::new(channel);
-
-    let key = Key::new();
-    let pubkey = key.pubkey.clone();
-
-    let req_data =
-        ListVmContractsReq { wallet: pubkey, uuid: String::from("uuid"), as_operator: false };
-
-    let mut grpc_stream =
-        client.list_vm_contracts(key.sign_request(req_data).unwrap()).await.unwrap().into_inner();
-
-    let mut vm_contracts = Vec::new();
-    while let Some(stream_update) = grpc_stream.next().await {
-        match stream_update {
-            Ok(vm_c) => {
-                vm_contracts.push(vm_c);
-            }
-            Err(e) => {
-                panic!("Received error instead of vm_contracts: {e:?}");
-            }
-        }
-    }
-
-    assert!(vm_contracts.is_empty())
-
-    // verify report in db
-}