From 32f6548eff8a1d7e2caa758444b70824677ecca8 Mon Sep 17 00:00:00 2001 From: Noor Date: Wed, 30 Apr 2025 02:09:14 +0530 Subject: [PATCH] seperating tests renamed a test file seperated daemon service tests modularizing test into reusable methods --- tests/common/prepare_test_env.rs | 1 + tests/common/test_utils.rs | 1 + tests/grpc_test.rs | 123 ++++++++++++++ .../{grpcs_test.rs => grpc_vm_daemon_test.rs} | 155 +++--------------- 4 files changed, 152 insertions(+), 128 deletions(-) create mode 100644 tests/grpc_test.rs rename tests/{grpcs_test.rs => grpc_vm_daemon_test.rs} (59%) diff --git a/tests/common/prepare_test_env.rs b/tests/common/prepare_test_env.rs index 0fd6699..2edd66b 100644 --- a/tests/common/prepare_test_env.rs +++ b/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 diff --git a/tests/common/test_utils.rs b/tests/common/test_utils.rs index 04a5b13..e5c9f27 100644 --- a/tests/common/test_utils.rs +++ b/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) -> Result { let pubkey = self.pubkey.clone(); let timestamp = chrono::Utc::now().to_rfc3339(); diff --git a/tests/grpc_test.rs b/tests/grpc_test.rs new file mode 100644 index 0000000..f9e6646 --- /dev/null +++ b/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 +} diff --git a/tests/grpcs_test.rs b/tests/grpc_vm_daemon_test.rs similarity index 59% rename from tests/grpcs_test.rs rename to tests/grpc_vm_daemon_test.rs index 1f00313..554b988 100644 --- a/tests/grpcs_test.rs +++ b/tests/grpc_vm_daemon_test.rs @@ -1,32 +1,41 @@ -use detee_shared::common_proto::Empty; -use detee_shared::general_proto::ReportNodeReq; +use common::{ + 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::{ - 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 detee_shared::vm_proto::RegisterVmNodeReq; 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, + key: Key, + operator_wallet: String, +) -> Vec { let node_pubkey = key.pubkey.clone(); let req = RegisterVmNodeReq { @@ -53,8 +62,7 @@ async fn test_reg_vm_node() { } } } - - assert!(vm_contracts.is_empty()) + vm_contracts } #[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 -}