brain-to-surreal/tests/grpcs_test.rs

use detee_shared::{
    common_proto::Pubkey,
    general_proto::{
        brain_general_cli_client::BrainGeneralCliClient,
        brain_general_cli_server::BrainGeneralCliServer,
    },
    vm_proto::brain_vm_cli_server::BrainVmCliServer,
};
use surreal_brain::grpc::{BrainGeneralCliMock, BrainVmCliMock};
use test_utils::{get_pub_key, sign_request};
use tokio::sync::OnceCell;
use tonic::transport::Channel;

mod test_utils;

const DB_URL: &str = "localhost:8000";
const DB_NS: &str = "test_brain";
const DB_NAME: &str = "test_migration_db";

const GRPC_ADDR: &str = "127.0.0.1:31337";

static TEST_STATE: OnceCell<Channel> = OnceCell::const_new();

async fn prepare_test_db() {
    surreal_brain::db::init(DB_URL, DB_NS, DB_NAME)
        .await
        .expect("Failed to initialize the database");

    let old_brain_data = surreal_brain::old_brain::BrainData::load_from_disk().unwrap();
    // cleanup old brain data
    surreal_brain::db::migration0(&old_brain_data).await.unwrap();
}

async fn fake_grpc_server() {
    tonic::transport::Server::builder()
        .add_service(BrainGeneralCliServer::new(BrainGeneralCliMock {}))
        .add_service(BrainVmCliServer::new(BrainVmCliMock {}))
        .serve(GRPC_ADDR.parse().unwrap())
        .await
        .unwrap();
}

async fn fake_grpc_client() -> Channel {
    let url = format!("http://{GRPC_ADDR}");
    Channel::from_shared(url).unwrap().connect().await.unwrap()
}

async fn prepare_test_setup() {
    TEST_STATE
        .get_or_init(|| async {
            prepare_test_db().await;

            tokio::spawn(async {
                fake_grpc_server().await;
            });

            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
            fake_grpc_client().await
        })
        .await;
}

#[tokio::test]
async fn test_general_balance() {
    prepare_test_setup().await;
    let grpc_channel = TEST_STATE.get().unwrap().clone();

    let mut brain_general_cli_client = BrainGeneralCliClient::new(grpc_channel.clone());

    let req_data = Pubkey { pubkey: get_pub_key().unwrap() };

    let acc_bal = brain_general_cli_client
        .get_balance(sign_request(req_data).unwrap())
        .await
        .unwrap()
        .into_inner();

    assert_eq!(acc_bal.balance, 0);
    assert_eq!(acc_bal.tmp_locked, 0);
}