testnet/brain
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

seperating tests

Browse Source 
renamed a test file
seperated daemon service tests
modularizing test into reusable methods
This commit is contained in:
Noor 2025-04-30 02:09:14 +05:30
parent a7268792ad
commit 32f6548eff
Signed by: noormohammedb
GPG Key ID: D83EFB8B3B967146
4 changed files with 152 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
tests/common/prepare_test_env.rs
View File

@ -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

1
tests/common/test_utils.rs
View File

@ -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();

123
tests/grpc_test.rs Normal file
View File

@ -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
}

155
tests/grpcs_test.rs → tests/grpc_vm_daemon_test.rs
View File

@ -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<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() {
}
}
}
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
}