test vm creation

add vm_cli_utils module
refactor test_report_node
validate report from db

tests/common/mod.rs

@@ -3,4 +3,6 @@ pub mod prepare_test_env;
 #[allow(dead_code)]
 pub mod test_utils;
 #[allow(dead_code)]
+pub mod vm_cli_utils;
+#[allow(dead_code)]
 pub mod vm_daemon_utils;

tests/common/vm_cli_utils.rs

@@ -0,0 +1,40 @@
+use super::test_utils::Key;
+use detee_shared::vm_proto;
+use detee_shared::vm_proto::brain_vm_cli_client::BrainVmCliClient;
+use surreal_brain::constants::{ACTIVE_VM, NEW_VM_REQ};
+use surreal_brain::db;
+use tonic::transport::Channel;
+
+pub async fn create_new_vm(key: Key, node_pubkey: String, brain_channel: Channel) -> String {
+    let new_vm_req = vm_proto::NewVmReq {
+        admin_pubkey: key.pubkey.clone(),
+        node_pubkey,
+        price_per_unit: 1200,
+        extra_ports: vec![8080, 8081],
+        locked_nano: 0,
+        ..Default::default()
+    };
+
+    let mut client_vm_cli = BrainVmCliClient::new(brain_channel.clone());
+    let new_vm_resp =
+        client_vm_cli.new_vm(key.sign_request(new_vm_req).unwrap()).await.unwrap().into_inner();
+
+    assert!(new_vm_resp.error.is_empty());
+    assert!(new_vm_resp.uuid.len() == 40);
+
+    // wait for update db
+    tokio::time::sleep(tokio::time::Duration::from_millis(700)).await;
+
+    let vm_req_db: Option<db::NewVmReq> =
+        db::DB.select((NEW_VM_REQ, new_vm_resp.uuid.clone())).await.unwrap();
+
+    if let Some(new_vm_req) = vm_req_db {
+        panic!("New VM request found in DB: {:?}", new_vm_req);
+    }
+
+    let active_vm_op: Option<db::ActiveVm> =
+        db::DB.select((ACTIVE_VM, new_vm_resp.uuid.clone())).await.unwrap();
+    let active_vm = active_vm_op.unwrap();
+
+    active_vm.id.key().to_string()
+}

tests/grpc_test.rs

@@ -1,6 +1,8 @@
 use common::{
     prepare_test_env::{prepare_test_db, run_service_for_stream, run_service_in_background},
     test_utils::Key,
+    vm_cli_utils::create_new_vm,
+    vm_daemon_utils::mock_vm_daemon,
 };
 use detee_shared::common_proto::Empty;
 use detee_shared::general_proto::ReportNodeReq;
@@ -10,6 +12,8 @@ use detee_shared::{
     common_proto::Pubkey, general_proto::brain_general_cli_client::BrainGeneralCliClient,
 };
 use futures::StreamExt;
+use surreal_brain::constants::VM_NODE;
+use surreal_brain::db::{self, VmNodeWithReports};
 
 mod common;
 
@@ -33,30 +37,70 @@ async fn test_general_balance() {
     assert_eq!(acc_bal.tmp_locked, 0);
 }
 
+#[tokio::test]
+async fn test_vm_creation() {
+    prepare_test_db().await;
+
+    let brain_channel = run_service_for_stream().await;
+    let daemon_key = mock_vm_daemon(brain_channel.clone()).await;
+
+    let key = Key::new();
+
+    let _ = create_new_vm(key.clone(), daemon_key.clone(), brain_channel.clone()).await;
+}
+
 #[tokio::test]
 async fn test_report_node() {
     prepare_test_db().await;
 
-    let addr = run_service_in_background().await;
+    let brain_channel = run_service_for_stream().await;
-    let mut client = BrainGeneralCliClient::connect(format!("http://{}", addr)).await.unwrap();
+    let daemon_key = mock_vm_daemon(brain_channel.clone()).await;
+    let mut client_gen_cli = BrainGeneralCliClient::new(brain_channel.clone());
 
     let key = Key::new();
     let pubkey = key.pubkey.clone();
 
-    // TODO: create contract, node and operator in db and use it here
+    let report_req = ReportNodeReq {
-    let req_data = ReportNodeReq {
+        admin_pubkey: pubkey.clone(),
-        admin_pubkey: pubkey,
+        node_pubkey: daemon_key.clone(),
-        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();
+    let report_error =
+        client_gen_cli.report_node(key.sign_request(report_req).unwrap()).await.err().unwrap();
 
     println!("Report error: {:?}", report_error);
     assert_eq!(report_error.message(), "No contract found by this ID.");
 
-    // verify report in db
+    let active_vm_id = create_new_vm(key.clone(), daemon_key.clone(), brain_channel.clone()).await;
+
+    let reason = String::from("something went wrong on vm");
+    let report_req = ReportNodeReq {
+        admin_pubkey: pubkey,
+        node_pubkey: daemon_key.clone(),
+        contract: active_vm_id,
+        reason: reason.clone(),
+    };
+
+    let _ = client_gen_cli
+        .report_node(key.sign_request(report_req).unwrap())
+        .await
+        .unwrap()
+        .into_inner();
+
+    let vm_nodes: Vec<VmNodeWithReports> = db::DB
+        .query(format!(
+            "SELECT *, <-report.* as reports FROM {VM_NODE} WHERE id = {VM_NODE}:{daemon_key};"
+        ))
+        .await
+        .unwrap()
+        .take(0)
+        .unwrap();
+
+    let vm_node_with_report = vm_nodes.get(0).unwrap();
+
+    assert!(vm_node_with_report.reports[0].reason == reason);
 }
 
 #[tokio::test]