140 lines
4.4 KiB
Rust
140 lines
4.4 KiB
Rust
use common::app_daemon_utils::{mock_app_daemon, register_app_node};
|
|
use common::prepare_test_env::{prepare_test_db, run_service_for_stream};
|
|
use common::test_utils::{airdrop, Key};
|
|
use detee_shared::app_proto::brain_app_cli_client::BrainAppCliClient;
|
|
use detee_shared::app_proto::brain_app_daemon_client::BrainAppDaemonClient;
|
|
use detee_shared::app_proto::{self, AppNodeResources};
|
|
use surreal_brain::constants::APP_NODE;
|
|
use surreal_brain::db::app::AppNode;
|
|
use surreal_brain::db::prelude as db;
|
|
use tokio_stream::wrappers::ReceiverStream;
|
|
|
|
mod common;
|
|
|
|
// TODO: test app registration and resource handling
|
|
|
|
#[tokio::test]
|
|
async fn test_reg_app_node() {
|
|
let db = prepare_test_db().await.unwrap();
|
|
|
|
let channel = run_service_for_stream().await.unwrap();
|
|
let mut client = BrainAppDaemonClient::new(channel);
|
|
|
|
let node_key = Key::new();
|
|
|
|
let del_app_req = register_app_node(&mut client, &node_key, &Key::new().pubkey).await.unwrap();
|
|
|
|
assert!(del_app_req.is_empty());
|
|
|
|
let app_node: Option<db::AppNode> = db.select((APP_NODE, node_key.pubkey)).await.unwrap();
|
|
assert!(app_node.is_some());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_brain_message() {
|
|
env_logger::builder().filter_level(log::LevelFilter::Error).init();
|
|
let _ = prepare_test_db().await.unwrap();
|
|
|
|
let brain_channel = run_service_for_stream().await.unwrap();
|
|
let daemon_key = mock_app_daemon(&brain_channel, None).await.unwrap();
|
|
let mut cli_client = BrainAppCliClient::new(brain_channel.clone());
|
|
|
|
let cli_key = Key::new();
|
|
|
|
let req = app_proto::NewAppReq {
|
|
admin_pubkey: cli_key.pubkey.clone(),
|
|
node_pubkey: daemon_key,
|
|
price_per_unit: 1200,
|
|
// extra_ports: vec![8080, 8081],
|
|
locked_nano: 100,
|
|
..Default::default()
|
|
};
|
|
airdrop(&brain_channel, &cli_key.pubkey, 10).await.unwrap();
|
|
let new_app_resp =
|
|
cli_client.new_app(cli_key.sign_request(req).unwrap()).await.unwrap().into_inner();
|
|
|
|
assert!(new_app_resp.error.is_empty());
|
|
assert!(new_app_resp.app_id.len() == 40);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_app_daemon_resource_msg() {
|
|
/*
|
|
env_logger::builder()
|
|
.filter_level(log::LevelFilter::Trace)
|
|
.filter_module("tungstenite", log::LevelFilter::Debug)
|
|
.filter_module("tokio_tungstenite", log::LevelFilter::Debug)
|
|
.init();
|
|
*/
|
|
|
|
let db = prepare_test_db().await.unwrap();
|
|
|
|
let brain_channel = run_service_for_stream().await.unwrap();
|
|
let mut daemon_client = BrainAppDaemonClient::new(brain_channel);
|
|
|
|
let daemon_key = Key::new();
|
|
|
|
register_app_node(&mut daemon_client, &daemon_key, &Key::new().pubkey).await.unwrap();
|
|
|
|
let (tx, rx) = tokio::sync::mpsc::channel(32);
|
|
|
|
let tx_01 = tx.clone();
|
|
let daemon_key_01 = daemon_key.clone();
|
|
|
|
tokio::spawn(async move {
|
|
tx_01
|
|
.send(app_proto::DaemonMessageApp {
|
|
msg: Some(app_proto::daemon_message_app::Msg::Auth(
|
|
daemon_key_01.clone().sign_stream_auth_app(vec![]).unwrap(),
|
|
)),
|
|
})
|
|
.await
|
|
.unwrap();
|
|
|
|
let rx_stream = ReceiverStream::new(rx);
|
|
daemon_client.daemon_messages(rx_stream).await.unwrap();
|
|
});
|
|
|
|
let tx_02 = tx.clone();
|
|
let daemon_pubkey = daemon_key.clone().pubkey;
|
|
|
|
let req_data = AppNodeResources {
|
|
node_pubkey: daemon_pubkey,
|
|
avail_no_of_port: 5,
|
|
avail_vcpus: 4,
|
|
avail_memory_mib: 8192,
|
|
avail_storage_mib: 10_0000,
|
|
max_ports_per_app: 5,
|
|
};
|
|
|
|
let req_data_copy = req_data.clone();
|
|
|
|
tokio::spawn(async move {
|
|
tx_02
|
|
.send(app_proto::DaemonMessageApp {
|
|
msg: Some(app_proto::daemon_message_app::Msg::AppNodeResources(req_data_copy)),
|
|
})
|
|
.await
|
|
.unwrap();
|
|
});
|
|
|
|
tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
|
|
|
|
let app_node_opt: Option<AppNode> = db.select((APP_NODE, daemon_key.pubkey)).await.unwrap();
|
|
assert!(app_node_opt.is_some());
|
|
let db::AppNode {
|
|
avail_mem_mib,
|
|
avail_vcpus,
|
|
avail_storage_mib,
|
|
avail_ports,
|
|
max_ports_per_app,
|
|
..
|
|
} = app_node_opt.unwrap();
|
|
|
|
assert_eq!(avail_mem_mib, req_data.avail_memory_mib);
|
|
assert_eq!(avail_vcpus, req_data.avail_vcpus);
|
|
assert_eq!(avail_storage_mib, req_data.avail_storage_mib);
|
|
assert_eq!(avail_ports, req_data.avail_no_of_port);
|
|
assert_eq!(max_ports_per_app, req_data.max_ports_per_app);
|
|
}
|