123 lines
3.5 KiB
Rust
123 lines
3.5 KiB
Rust
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,
|
|
};
|
|
mod common;
|
|
use common::prepare_test_env::{
|
|
prepare_test_db, run_service_for_stream, run_service_in_background,
|
|
};
|
|
use common::test_utils::Key;
|
|
use futures::StreamExt;
|
|
|
|
#[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
|
|
}
|