use common::prepare_test_env::{
    prepare_test_db, run_service_for_stream, run_service_in_background,
};
use common::test_utils::Key;
use common::vm_cli_utils::airdrop;
use common::vm_daemon_utils::{mock_vm_daemon, register_vm_node};
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;

mod common;

#[tokio::test]
async fn test_reg_vm_node() {
    prepare_test_db().await.unwrap();

    let addr = run_service_in_background().await.unwrap();
    let mut client = BrainVmDaemonClient::connect(format!("http://{}", addr)).await.unwrap();

    let vm_contracts =
        register_vm_node(&mut client, &Key::new(), &Key::new().pubkey).await.unwrap();

    assert!(vm_contracts.is_empty())
}

#[tokio::test]
async fn test_brain_message() {
    env_logger::builder().filter_level(log::LevelFilter::Error).init();
    prepare_test_db().await.unwrap();

    let brain_channel = run_service_for_stream().await.unwrap();
    let daemon_key = mock_vm_daemon(&brain_channel, None).await.unwrap();
    let mut cli_client = BrainVmCliClient::new(brain_channel.clone());

    let cli_key = Key::new();

    let req = vm_proto::NewVmReq {
        admin_pubkey: cli_key.pubkey.clone(),
        node_pubkey: daemon_key,
        price_per_unit: 1200,
        extra_ports: vec![8080, 8081],
        locked_nano: 0,
        ..Default::default()
    };
    airdrop(&brain_channel, &cli_key.pubkey, 10).await.unwrap();
    let new_vm_resp =
        cli_client.new_vm(cli_key.sign_request(req).unwrap()).await.unwrap().into_inner();

    assert!(new_vm_resp.error.is_empty());
    assert!(new_vm_resp.uuid.len() == 40);
    assert!(new_vm_resp.args.is_some());
    assert!(new_vm_resp.args.unwrap().exposed_ports.len() == 3);
}