src/db/general.rs

@@ -30,18 +30,6 @@ 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,8 +22,6 @@ 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,7 +3,6 @@ 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};
@@ -51,7 +50,6 @@ 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,8 +6,10 @@ use dotenv::dotenv;
 use hyper_util::rt::TokioIo;
 use std::net::SocketAddr;
 use std::sync::Arc;
-use surreal_brain::grpc::general::GeneralCliServer;
+use surreal_brain::grpc::{
-use surreal_brain::grpc::vm::{VmCliServer, VmDaemonServer};
+    general::GeneralCliServer,
+    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::{AirdropReq, ReportNodeReq};
+use detee_shared::general_proto::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,18 +11,6 @@ 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_test.rs

@@ -3,11 +3,12 @@ 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, register_vm_node};
+use common::vm_daemon_utils::mock_vm_daemon;
 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_daemon_client::BrainVmDaemonClient;
+use detee_shared::vm_proto::brain_vm_cli_client::BrainVmCliClient;
+use detee_shared::vm_proto::ListVmContractsReq;
 use futures::StreamExt;
 use itertools::Itertools;
 use std::vec;
@@ -112,6 +113,18 @@ 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();
@@ -180,34 +193,35 @@ async fn test_list_operators() {
 }
 
 #[tokio::test]
-async fn test_inspect_operator() {
+// TODO: create vm for this user before testing this
+async fn test_list_vm_contracts() {
     prepare_test_db().await.unwrap();
 
-    let brain_channel = run_service_for_stream().await.unwrap();
+    let channel = run_service_for_stream().await.unwrap();
-    let mut cli_client = BrainGeneralCliClient::new(brain_channel.clone());
+    let mut client = BrainVmCliClient::new(channel);
-    let mut daemon_client = BrainVmDaemonClient::new(brain_channel.clone());
+
     let key = Key::new();
-    let daemon_key = Key::new();
+    let pubkey = key.pubkey.clone();
-    let operator_key = Key::new();
 
-    let err = cli_client
+    let req_data =
-        .inspect_operator(key.sign_request(Pubkey { pubkey: operator_key.pubkey.clone() }).unwrap())
+        ListVmContractsReq { wallet: pubkey, uuid: String::from("uuid"), as_operator: false };
-        .await
-        .err()
-        .unwrap();
 
-    assert_eq!(err.message(), "The wallet you specified is not an operator");
+    let mut grpc_stream =
+        client.list_vm_contracts(key.sign_request(req_data).unwrap()).await.unwrap().into_inner();
 
-    // TODO: test with app node also
+    let mut vm_contracts = Vec::new();
-    register_vm_node(&mut daemon_client, &daemon_key, &operator_key.pubkey).await.unwrap();
+    while let Some(stream_update) = grpc_stream.next().await {
-
+        match stream_update {
-    let inspect_response = cli_client
+            Ok(vm_c) => {
-        .inspect_operator(key.sign_request(Pubkey { pubkey: operator_key.pubkey.clone() }).unwrap())
+                vm_contracts.push(vm_c);
-        .await
+            }
-        .unwrap()
+            Err(e) => {
-        .into_inner();
+                panic!("Received error instead of vm_contracts: {e:?}");
-
+            }
-    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);
+
+    assert!(vm_contracts.is_empty())
+
+    // verify report in db
 }

tests/grpc_vm_cli_test.rs

@@ -1,90 +0,0 @@
-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
-}