brain/tests/grpcs_test.rs

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::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,
};
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_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 operator_wallet = Key::new().pubkey;

    let key = Key::new();

    let node_pubkey = key.pubkey.clone();

    let req = RegisterVmNodeReq {
        node_pubkey,
        operator_wallet,
        main_ip: String::from("185.243.218.213"),
        city: String::from("Oslo"),
        country: String::from("Norway"),
        region: String::from("EU"),
        price: 1200,
    };

    let mut grpc_stream =
        client.register_vm_node(key.sign_request(req).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())
}

#[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
}