test listing operators and list vm contracts

test report node

Cargo.lock

@@ -3771,6 +3771,7 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 name = "surreal-brain"
 version = "0.1.0"
 dependencies = [
+ "anyhow",
  "bs58",
  "chrono",
  "dashmap 6.1.0",

Cargo.toml

@@ -27,3 +27,8 @@ strip = true
 opt-level = 3
 panic = 'abort'
 codegen-units = 1
+
+[dev-dependencies]
+anyhow = "1.0.98"
+bs58 = "0.5.1"
+ed25519-dalek = "2.1.1"

src/bin/brain.rs

@@ -1,21 +1,24 @@
 use detee_shared::general_proto::brain_general_cli_server::BrainGeneralCliServer;
 use detee_shared::vm_proto::brain_vm_cli_server::BrainVmCliServer;
+use surreal_brain::constants::{
+    BRAIN_GRPC_ADDR, CERT_KEY_PATH, CERT_PATH, DB_ADDRESS, DB_NAME, DB_NS,
+};
+use surreal_brain::db;
 use surreal_brain::grpc::BrainGeneralCliMock;
 use surreal_brain::grpc::BrainVmCliMock;
-use surreal_brain::db;
 use tonic::transport::{Identity, Server, ServerTlsConfig};
 
 #[tokio::main]
 async fn main() {
     env_logger::builder().filter_level(log::LevelFilter::Debug).init();
-    db::init().await.unwrap();
-    let addr = "0.0.0.0:31337".parse().unwrap();
+    db::init(DB_ADDRESS, DB_NS, DB_NAME).await.unwrap();
+    let addr = BRAIN_GRPC_ADDR.parse().unwrap();
 
     let snp_cli_server = BrainVmCliServer::new(BrainVmCliMock {});
     let general_service_server = BrainGeneralCliServer::new(BrainGeneralCliMock {});
 
-    let cert = std::fs::read_to_string("./tmp/brain-crt.pem").unwrap();
-    let key = std::fs::read_to_string("./tmp/brain-key.pem").unwrap();
+    let cert = std::fs::read_to_string(CERT_PATH).unwrap();
+    let key = std::fs::read_to_string(CERT_KEY_PATH).unwrap();
 
     let identity = Identity::from_pem(cert, key);
 

src/bin/migration0.rs

@@ -1,6 +1,8 @@
 // After deleting this migration, also delete old_brain structs
 // and dangling impls from the model
 use std::error::Error;
+use surreal_brain::constants::{DB_ADDRESS, DB_NAME, DB_NS};
+use surreal_brain::db::init;
 use surreal_brain::{db, old_brain};
 
 #[tokio::main]
@@ -8,6 +10,8 @@ async fn main() -> Result<(), Box<dyn Error>> {
     let old_brain_data = old_brain::BrainData::load_from_disk()?;
     // println!("{}", serde_yaml::to_string(&old_brain_data)?);
 
+    init(DB_ADDRESS, DB_NS, DB_NAME).await?;
+
     let result = db::migration0(&old_brain_data).await?;
 
     println!("{result:?}");

src/constants.rs

@@ -0,0 +1,24 @@
+pub const BRAIN_GRPC_ADDR: &str = "0.0.0.0:31337";
+pub const CERT_PATH: &str = "./tmp/brain-crt.pem";
+pub const CERT_KEY_PATH: &str = "./tmp/brain-key.pem";
+
+pub const DB_ADDRESS: &str = "localhost:8000";
+pub const DB_NS: &str = "brain";
+pub const DB_NAME: &str = "migration";
+
+// TODO: read from .env
+pub const DB_USER: &str = "root";
+pub const DB_PASS: &str = "root";
+
+pub const ACCOUNT: &str = "account";
+pub const OPERATOR: &str = "operator";
+pub const VM_CONTRACT: &str = "vm_contract";
+pub const VM_NODE: &str = "vm_node";
+
+pub const ADMIN_ACCOUNTS: &[&str] = &[
+    "x52w7jARC5erhWWK65VZmjdGXzBK6ZDgfv1A283d8XK",
+    "FHuecMbeC1PfjkW2JKyoicJAuiU7khgQT16QUB3Q1XdL",
+    "H21Shi4iE7vgfjWEQNvzmpmBMJSaiZ17PYUcdNoAoKNc",
+];
+
+pub const OLD_BRAIN_DATA_PATH: &str = "./saved_data.yaml";

src/db.rs

@@ -8,11 +8,9 @@ use surrealdb::{
     RecordId, Surreal,
 };
 
-static DB: LazyLock<Surreal<Client>> = LazyLock::new(Surreal::init);
-const ACCOUNT: &str = "account";
-const OPERATOR: &str = "operator";
-const VM_CONTRACT: &str = "vm_contract";
-const VM_NODE: &str = "vm_node";
+use crate::constants::{ACCOUNT, DB_PASS, DB_USER, OPERATOR, VM_CONTRACT, VM_NODE};
+
+pub static DB: LazyLock<Surreal<Client>> = LazyLock::new(Surreal::init);
 
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
@@ -20,11 +18,11 @@ pub enum Error {
     DataBase(#[from] surrealdb::Error),
 }
 
-pub async fn init() -> surrealdb::Result<()> {
-    DB.connect::<Ws>("localhost:8000").await?;
+pub async fn init(db_address: &str, ns: &str, db: &str) -> surrealdb::Result<()> {
+    DB.connect::<Ws>(db_address).await?;
     // Sign in to the server
-    DB.signin(Root { username: "root", password: "root" }).await?;
-    DB.use_ns("brain").use_db("migration").await?;
+    DB.signin(Root { username: DB_USER, password: DB_PASS }).await?;
+    DB.use_ns(ns).use_db(db).await?;
     Ok(())
 }
 
@@ -35,8 +33,6 @@ pub async fn migration0(old_data: &old_brain::BrainData) -> surrealdb::Result<()
     let vm_contracts: Vec<VmContract> = old_data.into();
     let operators: Vec<OperatorRelation> = old_data.into();
 
-    init().await?;
-
     println!("Inserting accounts...");
     let _: Vec<Account> = DB.insert(()).content(accounts).await?;
     println!("Inserting vm nodes...");
@@ -293,7 +289,11 @@ pub struct Report {
 
 impl Report {
     // TODO: test this functionality and remove this comment
-    pub async fn create(from_account: RecordId, to_node: RecordId, reason: String) -> Result<(), Error> {
+    pub async fn create(
+        from_account: RecordId,
+        to_node: RecordId,
+        reason: String,
+    ) -> Result<(), Error> {
         let _: Vec<Self> = DB
             .insert("report")
             .relation(Report { from_account, to_node, created_at: Datetime::default(), reason })

src/grpc.rs

@@ -1,4 +1,5 @@
 #![allow(dead_code)]
+use crate::constants::ADMIN_ACCOUNTS;
 use crate::db;
 use detee_shared::app_proto::AppContract;
 use detee_shared::{
@@ -499,12 +500,6 @@ fn check_sig_from_req<T: std::fmt::Debug + PubkeyGetter>(req: Request<T>) -> Res
     Ok(req)
 }
 
-const ADMIN_ACCOUNTS: &[&str] = &[
-    "x52w7jARC5erhWWK65VZmjdGXzBK6ZDgfv1A283d8XK",
-    "FHuecMbeC1PfjkW2JKyoicJAuiU7khgQT16QUB3Q1XdL",
-    "H21Shi4iE7vgfjWEQNvzmpmBMJSaiZ17PYUcdNoAoKNc",
-];
-
 fn check_admin_key<T>(req: &Request<T>) -> Result<(), Status> {
     let pubkey = match req.metadata().get("pubkey") {
         Some(p) => p.clone(),

src/lib.rs

@@ -1,3 +1,4 @@
-pub mod grpc;
+pub mod constants;
 pub mod db;
+pub mod grpc;
 pub mod old_brain;

src/old_brain.rs

@@ -5,6 +5,8 @@ use dashmap::DashMap;
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet};
 
+use crate::constants::OLD_BRAIN_DATA_PATH;
+
 #[derive(Clone, Default, Serialize, Deserialize, Debug)]
 pub struct AccountData {
     pub balance: u64,
@@ -124,7 +126,7 @@ pub struct BrainData {
 
 impl BrainData {
     pub fn load_from_disk() -> Result<Self, Box<dyn std::error::Error>> {
-        let content = std::fs::read_to_string("./saved_data.yaml")?;
+        let content = std::fs::read_to_string(OLD_BRAIN_DATA_PATH)?;
         let data: Self = serde_yaml::from_str(&content)?;
         Ok(data)
     }

tests/common/mod.rs

@@ -0,0 +1,2 @@
+pub mod prepare_test_env;
+pub mod test_utils;

tests/common/prepare_test_env.rs

@@ -0,0 +1,54 @@
+use detee_shared::{
+    general_proto::brain_general_cli_server::BrainGeneralCliServer,
+    vm_proto::brain_vm_cli_server::BrainVmCliServer,
+};
+use surreal_brain::grpc::{BrainGeneralCliMock, BrainVmCliMock};
+use tokio::sync::OnceCell;
+use tonic::transport::Channel;
+
+pub const DB_URL: &str = "localhost:8000";
+pub const DB_NS: &str = "test_brain";
+pub const DB_NAME: &str = "test_migration_db";
+
+pub const GRPC_ADDR: &str = "127.0.0.1:31337";
+
+pub static TEST_STATE: OnceCell<Channel> = OnceCell::const_new();
+
+pub async fn prepare_test_db() {
+    surreal_brain::db::init(DB_URL, DB_NS, DB_NAME)
+        .await
+        .expect("Failed to initialize the database");
+
+    let old_brain_data = surreal_brain::old_brain::BrainData::load_from_disk().unwrap();
+    let _ = surreal_brain::db::DB.query(format!("REMOVE DATABASE {DB_NAME}")).await;
+    surreal_brain::db::migration0(&old_brain_data).await.unwrap();
+}
+
+pub async fn fake_grpc_server() {
+    tonic::transport::Server::builder()
+        .add_service(BrainGeneralCliServer::new(BrainGeneralCliMock {}))
+        .add_service(BrainVmCliServer::new(BrainVmCliMock {}))
+        .serve(GRPC_ADDR.parse().unwrap())
+        .await
+        .unwrap();
+}
+
+pub async fn fake_grpc_client() -> Channel {
+    let url = format!("http://{GRPC_ADDR}");
+    Channel::from_shared(url).unwrap().connect().await.unwrap()
+}
+
+pub async fn prepare_test_setup() {
+    TEST_STATE
+        .get_or_init(|| async {
+            prepare_test_db().await;
+
+            tokio::spawn(async {
+                fake_grpc_server().await;
+            });
+
+            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+            fake_grpc_client().await
+        })
+        .await;
+}

tests/common/test_utils.rs

@@ -0,0 +1,41 @@
+use anyhow::Result;
+use ed25519_dalek::Signer;
+use ed25519_dalek::SigningKey;
+use tonic::metadata::AsciiMetadataValue;
+use tonic::Request;
+
+pub const WALLET_KEY_PATH: &str = "tests/fixtures/secret_detee_wallet_key";
+
+pub fn sign_request<T: std::fmt::Debug>(req: T) -> Result<Request<T>> {
+    let pubkey = get_pub_key()?;
+    let timestamp = chrono::Utc::now().to_rfc3339();
+    let signature = try_sign_message(&format!("{timestamp}{req:?}"))?;
+    let timestamp: AsciiMetadataValue = timestamp.parse()?;
+    let pubkey: AsciiMetadataValue = pubkey.parse()?;
+    let signature: AsciiMetadataValue = signature.parse()?;
+    let mut req = Request::new(req);
+    req.metadata_mut().insert("timestamp", timestamp);
+    req.metadata_mut().insert("pubkey", pubkey);
+    req.metadata_mut().insert("request-signature", signature);
+
+    Ok(req)
+}
+
+fn get_signing_key() -> Result<SigningKey> {
+    let key = bs58::decode(std::fs::read_to_string(WALLET_KEY_PATH)?.trim())
+        .into_vec()?
+        .try_into()
+        .map_err(|e: Vec<u8>| anyhow::anyhow!("Invalid key length: {}", e.len()))?;
+    let key = SigningKey::from_bytes(&key);
+    Ok(key)
+}
+
+pub fn get_pub_key() -> Result<String> {
+    let key = get_signing_key()?;
+    Ok(bs58::encode(key.verifying_key().to_bytes()).into_string())
+}
+
+pub fn try_sign_message(message: &str) -> Result<String> {
+    let key = get_signing_key()?;
+    Ok(bs58::encode(key.sign(message.as_bytes()).to_bytes()).into_string())
+}

tests/fixtures/secret_detee_wallet_key

@@ -0,0 +1 @@
+9RBoFzqSfMVjQmmCbnMhfNGxGEdRmTyb9eF4wDdRVX6f

tests/grpcs_test.rs

@@ -0,0 +1,123 @@
+use detee_shared::common_proto::Empty;
+use detee_shared::general_proto::ReportNodeReq;
+use detee_shared::vm_proto::brain_vm_cli_client::BrainVmCliClient;
+use detee_shared::vm_proto::ListVmContractsReq;
+use detee_shared::{
+    common_proto::Pubkey, general_proto::brain_general_cli_client::BrainGeneralCliClient,
+};
+mod common;
+use common::prepare_test_env::{prepare_test_setup, TEST_STATE};
+use common::test_utils::{get_pub_key, sign_request};
+use tokio_stream::StreamExt;
+
+#[tokio::test]
+async fn test_general_balance() {
+    prepare_test_setup().await;
+    let grpc_channel = TEST_STATE.get().unwrap().clone();
+
+    let mut brain_general_cli_client = BrainGeneralCliClient::new(grpc_channel.clone());
+
+    let req_data = Pubkey { pubkey: get_pub_key().unwrap() };
+
+    let acc_bal = brain_general_cli_client
+        .get_balance(sign_request(req_data).unwrap())
+        .await
+        .unwrap()
+        .into_inner();
+
+    // verify it in db also
+
+    assert_eq!(acc_bal.balance, 0);
+    assert_eq!(acc_bal.tmp_locked, 0);
+}
+
+#[tokio::test]
+async fn test_report_node() {
+    prepare_test_setup().await;
+    let grpc_channel = TEST_STATE.get().unwrap().clone();
+
+    let mut brain_general_cli_client = BrainGeneralCliClient::new(grpc_channel.clone());
+
+    // TODO: create contract, node and operator in db and use it here
+    let req_data = ReportNodeReq {
+        admin_pubkey: get_pub_key().unwrap(),
+        node_pubkey: String::from("node_pubkey"),
+        contract: String::from("uuid"),
+        reason: String::from("reason"),
+    };
+
+    let report_error =
+        brain_general_cli_client.report_node(sign_request(req_data).unwrap()).await.err().unwrap();
+
+    assert_eq!(report_error.message(), "No contract found by this ID.");
+
+    // verify report in db
+}
+
+#[tokio::test]
+// TODO: register some operators before testing this
+async fn test_list_operators() {
+    prepare_test_setup().await;
+    let grpc_channel = TEST_STATE.get().unwrap().clone();
+
+    let mut brain_general_cli_client = BrainGeneralCliClient::new(grpc_channel.clone());
+
+    let mut grpc_stream = brain_general_cli_client
+        .list_operators(sign_request(Empty {}).unwrap())
+        .await
+        .unwrap()
+        .into_inner();
+
+    let mut operators = Vec::new();
+    while let Some(stream_update) = grpc_stream.next().await {
+        match stream_update {
+            Ok(op) => {
+                operators.push(op);
+            }
+            Err(e) => {
+                panic!("Received error instead of operators: {e:?}");
+            }
+        }
+    }
+
+    assert!(!operators.is_empty())
+
+    // verify report in db
+}
+
+#[tokio::test]
+// TODO: create vm for this user before testing this
+async fn test_list_vm_contracts() {
+    prepare_test_setup().await;
+    let grpc_channel = TEST_STATE.get().unwrap().clone();
+
+    let mut brain_general_cli_client = BrainVmCliClient::new(grpc_channel.clone());
+
+    let req_data = ListVmContractsReq {
+        wallet: get_pub_key().unwrap(),
+        uuid: String::from("uuid"),
+        as_operator: false,
+    };
+
+    let mut grpc_stream = brain_general_cli_client
+        .list_vm_contracts(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
+}