test for operator inspection

format tests
seperated vm tests into its module

src/db/general.rs

@@ -30,6 +30,18 @@ impl Account {
         Ok(account)
     }
 
+    pub async fn get_or_create(db: &Surreal<Client>, address: &str) -> Result<Self, Error> {
+        let id = (ACCOUNT, address);
+
+        match db.select(id).await? {
+            Some(account) => Ok(account),
+            None => {
+                let account: Option<Self> = db.create(id).await?;
+                account.ok_or(Error::FailedToCreateDBEntry)
+            }
+        }
+    }
+
     pub async fn airdrop(db: &Surreal<Client>, account: &str, tokens: u64) -> Result<(), Error> {
         let tokens = tokens.saturating_mul(1_000_000_000);
         let _ = db

src/db/mod.rs

@@ -22,6 +22,8 @@ pub enum Error {
     StdIo(#[from] std::io::Error),
     #[error(transparent)]
     TimeOut(#[from] tokio::time::error::Elapsed),
+    #[error("Failed to create account")]
+    FailedToCreateDBEntry,
 }
 
 pub mod prelude {

src/db/vm.rs

@@ -3,6 +3,7 @@ use std::time::Duration;
 
 use super::Error;
 use crate::constants::{ACCOUNT, ACTIVE_VM, DELETED_VM, NEW_VM_REQ, VM_NODE};
+use crate::db::general;
 use crate::db::general::Report;
 use crate::old_brain;
 use serde::{Deserialize, Serialize};
@@ -50,6 +51,7 @@ impl VmNodeResources {
 
 impl VmNode {
     pub async fn register(self, db: &Surreal<Client>) -> Result<(), Error> {
+        general::Account::get_or_create(db, &self.operator.key().to_string()).await?;
         let _: Option<VmNode> = db.upsert(self.id.clone()).content(self).await?;
         Ok(())
     }

tests/common/prepare_test_env.rs

@@ -6,10 +6,8 @@ use dotenv::dotenv;
 use hyper_util::rt::TokioIo;
 use std::net::SocketAddr;
 use std::sync::Arc;
-use surreal_brain::grpc::{
+use surreal_brain::grpc::general::GeneralCliServer;
-    general::GeneralCliServer,
+use surreal_brain::grpc::vm::{VmCliServer, VmDaemonServer};
-    vm::{VmCliServer, VmDaemonServer},
-};
 use surrealdb::engine::remote::ws::Client;
 use surrealdb::Surreal;
 use tokio::io::DuplexStream;

tests/common/vm_cli_utils.rs

@@ -2,7 +2,7 @@ use super::test_utils::Key;
 use anyhow::{anyhow, Result};
 use detee_shared::common_proto::Empty;
 use detee_shared::general_proto::brain_general_cli_client::BrainGeneralCliClient;
-use detee_shared::general_proto::ReportNodeReq;
+use detee_shared::general_proto::{AirdropReq, ReportNodeReq};
 use detee_shared::vm_proto;
 use detee_shared::vm_proto::brain_vm_cli_client::BrainVmCliClient;
 use surreal_brain::constants::{ACTIVE_VM, NEW_VM_REQ};
@@ -11,6 +11,18 @@ use surrealdb::engine::remote::ws::Client;
 use surrealdb::Surreal;
 use tonic::transport::Channel;
 
+async fn airdrop(brain_channel: &Channel, wallet: &str, amount: u64) -> Result<()> {
+    let mut client = BrainGeneralCliClient::new(brain_channel.clone());
+    let airdrop_req = AirdropReq { pubkey: wallet.to_string(), tokens: amount };
+
+    let admin_key = Key::new();
+    std::env::set_var("ADMIN_PUB_KEYS", &admin_key.pubkey);
+
+    client.airdrop(admin_key.sign_request(airdrop_req.clone())?).await?;
+
+    Ok(())
+}
+
 pub async fn create_new_vm(
     db: &Surreal<Client>,
     key: &Key,

tests/grpc_general_test.rs

@@ -3,12 +3,11 @@ use common::prepare_test_env::{
 };
 use common::test_utils::Key;
 use common::vm_cli_utils::{create_new_vm, report_node};
-use common::vm_daemon_utils::mock_vm_daemon;
+use common::vm_daemon_utils::{mock_vm_daemon, register_vm_node};
 use detee_shared::common_proto::{Empty, Pubkey};
 use detee_shared::general_proto::brain_general_cli_client::BrainGeneralCliClient;
 use detee_shared::general_proto::AirdropReq;
-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;
 use futures::StreamExt;
 use itertools::Itertools;
 use std::vec;
@@ -113,18 +112,6 @@ async fn test_general_airdrop() {
     assert_eq!(acc_bal_admin_3.balance, airdrop_amount * AIRDROP_MULTIPLE);
 }
 
-#[tokio::test]
-async fn test_vm_creation() {
-    let db = prepare_test_db().await.unwrap();
-
-    let brain_channel = run_service_for_stream().await.unwrap();
-    let daemon_key = mock_vm_daemon(&brain_channel).await.unwrap();
-
-    let key = Key::new();
-
-    let _ = create_new_vm(&db, &key, &daemon_key, &brain_channel).await;
-}
-
 #[tokio::test]
 async fn test_report_node() {
     let db = prepare_test_db().await.unwrap();
@@ -193,35 +180,34 @@ async fn test_list_operators() {
 }
 
 #[tokio::test]
-// TODO: create vm for this user before testing this
+async fn test_inspect_operator() {
-async fn test_list_vm_contracts() {
     prepare_test_db().await.unwrap();
 
-    let channel = run_service_for_stream().await.unwrap();
+    let brain_channel = run_service_for_stream().await.unwrap();
-    let mut client = BrainVmCliClient::new(channel);
+    let mut cli_client = BrainGeneralCliClient::new(brain_channel.clone());
-
+    let mut daemon_client = BrainVmDaemonClient::new(brain_channel.clone());
     let key = Key::new();
-    let pubkey = key.pubkey.clone();
+    let daemon_key = Key::new();
+    let operator_key = Key::new();
 
-    let req_data =
+    let err = cli_client
-        ListVmContractsReq { wallet: pubkey, uuid: String::from("uuid"), as_operator: false };
+        .inspect_operator(key.sign_request(Pubkey { pubkey: operator_key.pubkey.clone() }).unwrap())
+        .await
+        .err()
+        .unwrap();
 
-    let mut grpc_stream =
+    assert_eq!(err.message(), "The wallet you specified is not an operator");
-        client.list_vm_contracts(key.sign_request(req_data).unwrap()).await.unwrap().into_inner();
 
-    let mut vm_contracts = Vec::new();
+    // TODO: test with app node also
-    while let Some(stream_update) = grpc_stream.next().await {
+    register_vm_node(&mut daemon_client, &daemon_key, &operator_key.pubkey).await.unwrap();
-        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())
+    let inspect_response = cli_client
+        .inspect_operator(key.sign_request(Pubkey { pubkey: operator_key.pubkey.clone() }).unwrap())
+        .await
+        .unwrap()
+        .into_inner();
 
-    // verify report in db
+    assert!(inspect_response.app_nodes.is_empty());
+    assert!(!inspect_response.vm_nodes.is_empty());
+    assert_eq!(&inspect_response.vm_nodes[0].operator, &operator_key.pubkey);
 }

tests/grpc_vm_cli_test.rs

@@ -0,0 +1,90 @@
+use common::prepare_test_env::{prepare_test_db, run_service_for_stream};
+use common::test_utils::Key;
+use common::vm_cli_utils::create_new_vm;
+use common::vm_daemon_utils::{mock_vm_daemon, register_vm_node};
+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, NewVmReq};
+use futures::StreamExt;
+use std::vec;
+
+mod common;
+
+#[tokio::test]
+async fn test_vm_creation() {
+    let db = prepare_test_db().await.unwrap();
+    // env_logger::builder().filter_level(log::LevelFilter::Error).init();
+
+    let brain_channel = run_service_for_stream().await.unwrap();
+    let daemon_key = mock_vm_daemon(&brain_channel).await.unwrap();
+
+    let key = Key::new();
+
+    let _ = create_new_vm(&db, &key, &daemon_key, &brain_channel).await;
+}
+
+#[tokio::test]
+async fn test_vm_creation_timeout() {
+    prepare_test_db().await.unwrap();
+    // env_logger::builder().filter_level(log::LevelFilter::Error).init();
+
+    let brain_channel = run_service_for_stream().await.unwrap();
+    let mut daemon_client = BrainVmDaemonClient::new(brain_channel.clone());
+    let daemon_key = Key::new();
+
+    register_vm_node(&mut daemon_client, &daemon_key, &Key::new().pubkey).await.unwrap();
+
+    let key = Key::new();
+
+    let new_vm_req = NewVmReq {
+        admin_pubkey: key.pubkey.clone(),
+        node_pubkey: daemon_key.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 timeout_error =
+        client_vm_cli.new_vm(key.sign_request(new_vm_req).unwrap()).await.err().unwrap();
+
+    assert_eq!(
+        timeout_error.message(),
+        "Request failed due to timeout. Please try again later or contact the DeTEE devs team."
+    )
+}
+
+#[tokio::test]
+// TODO: create vm for this user before testing this
+async fn test_list_vm_contracts() {
+    prepare_test_db().await.unwrap();
+
+    let channel = run_service_for_stream().await.unwrap();
+    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
+}