test with new keys

create new keys for each test
deleted static key

Cargo.lock

@@ -1106,6 +1106,7 @@ checksum = "4a3daa8e81a3963a60642bcc1f90a670680bd4a77535faa384e9d1c79d620871"
 dependencies = [
  "curve25519-dalek",
  "ed25519",
+ "rand_core 0.6.4",
  "serde",
  "sha2",
  "subtle",
@@ -3782,6 +3783,7 @@ dependencies = [
  "hyper-util",
  "log",
  "nanoid",
+ "rand 0.8.5",
  "serde",
  "serde_json",
  "serde_yaml",

Cargo.toml

@@ -32,6 +32,7 @@ codegen-units = 1
 [dev-dependencies]
 anyhow = "1.0.98"
 bs58 = "0.5.1"
-ed25519-dalek = "2.1.1"
+ed25519-dalek = { version = "2.1.1", features = ["rand_core"] }
 hyper-util = "0.1.11"
+rand = "0.8"
 tower = "0.5.2"

tests/common/prepare_test_env.rs

@@ -1,8 +1,11 @@
-use detee_shared::general_proto::brain_general_cli_server::BrainGeneralCliServer;
 use detee_shared::vm_proto::brain_vm_cli_server::BrainVmCliServer;
+use detee_shared::{
+    general_proto::brain_general_cli_server::BrainGeneralCliServer,
+    vm_proto::brain_vm_daemon_server::BrainVmDaemonServer,
+};
 use hyper_util::rt::TokioIo;
 use std::net::SocketAddr;
-use surreal_brain::grpc::{BrainGeneralCliForReal, BrainVmCliForReal};
+use surreal_brain::grpc::{BrainGeneralCliForReal, BrainVmCliForReal, BrainVmDaemonForReal};
 use tokio::{net::TcpListener, sync::OnceCell};
 use tonic::transport::{Channel, Endpoint, Server, Uri};
 use tower::service_fn;
@@ -49,6 +52,7 @@ pub async fn run_service_in_background() -> SocketAddr {
         Server::builder()
             .add_service(BrainGeneralCliServer::new(BrainGeneralCliForReal {}))
             .add_service(BrainVmCliServer::new(BrainVmCliForReal {}))
+            .add_service(BrainVmDaemonServer::new(BrainVmDaemonForReal {}))
             .serve_with_incoming(tokio_stream::wrappers::TcpListenerStream::new(listener))
             .await
             .unwrap();
@@ -70,6 +74,7 @@ pub async fn run_service_for_stream() -> Channel {
         tonic::transport::Server::builder()
             .add_service(BrainGeneralCliServer::new(BrainGeneralCliForReal {}))
             .add_service(BrainVmCliServer::new(BrainVmCliForReal {}))
+            .add_service(BrainVmDaemonServer::new(BrainVmDaemonForReal {}))
             .serve_with_incoming(tokio_stream::once(Ok::<_, std::io::Error>(server)))
             .await
     });

tests/common/test_utils.rs

@@ -4,12 +4,22 @@ use ed25519_dalek::SigningKey;
 use tonic::metadata::AsciiMetadataValue;
 use tonic::Request;
 
-pub const WALLET_KEY_PATH: &str = "tests/fixtures/secret_detee_wallet_key";
+pub struct Key {
+    pub sg_key: SigningKey,
+    pub pubkey: String,
+}
 
-pub fn sign_request<T: std::fmt::Debug>(req: T) -> Result<Request<T>> {
+impl Key {
-    let pubkey = get_pub_key()?;
+    pub fn new() -> Self {
+        let sk = SigningKey::generate(&mut rand::rngs::OsRng);
+        let pubkey = bs58::encode(sk.verifying_key().to_bytes()).into_string();
+        Key { sg_key: sk, pubkey }
+    }
+
+    pub fn sign_request<T: std::fmt::Debug>(&self, req: T) -> Result<Request<T>> {
+        let pubkey = self.pubkey.clone();
         let timestamp = chrono::Utc::now().to_rfc3339();
-    let signature = try_sign_message(&format!("{timestamp}{req:?}"))?;
+        let signature = self.try_sign_message(&format!("{timestamp}{req:?}"))?;
         let timestamp: AsciiMetadataValue = timestamp.parse()?;
         let pubkey: AsciiMetadataValue = pubkey.parse()?;
         let signature: AsciiMetadataValue = signature.parse()?;
@@ -19,23 +29,10 @@ pub fn sign_request<T: std::fmt::Debug>(req: T) -> Result<Request<T>> {
         req.metadata_mut().insert("request-signature", signature);
 
         Ok(req)
-}
+    }
 
-fn get_signing_key() -> Result<SigningKey> {
+    pub fn try_sign_message(&self, message: &str) -> Result<String> {
-    let key = bs58::decode(std::fs::read_to_string(WALLET_KEY_PATH)?.trim())
+        let key = self.sg_key.clone();
-        .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

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

tests/grpcs_test.rs

@@ -9,7 +9,7 @@ mod common;
 use common::prepare_test_env::{
     prepare_test_db, run_service_for_stream, run_service_in_background,
 };
-use common::test_utils::{get_pub_key, sign_request};
+use common::test_utils::Key;
 use futures::StreamExt;
 
 #[tokio::test]
@@ -20,10 +20,11 @@ async fn test_general_balance() {
     let addr = run_service_in_background().await;
     let mut client = BrainGeneralCliClient::connect(format!("http://{}", addr)).await.unwrap();
 
-    let pubkey = get_pub_key().unwrap();
+    let key = Key::new();
-    let req_data = Pubkey { pubkey: pubkey.clone() };
+    let pubkey = key.pubkey.clone();
+    let req_data = Pubkey { pubkey };
 
-    let req = sign_request(req_data).unwrap();
+    let req = key.sign_request(req_data).unwrap();
 
     let acc_bal = client.get_balance(req).await.unwrap().into_inner();
 
@@ -33,21 +34,25 @@ async fn test_general_balance() {
 
 #[tokio::test]
 async fn test_report_node() {
-    let _ = prepare_test_db().await;
+    prepare_test_db().await;
 
     let addr = run_service_in_background().await;
     let mut client = BrainGeneralCliClient::connect(format!("http://{}", addr)).await.unwrap();
 
+    let key = Key::new();
+    let pubkey = key.pubkey.clone();
+
     // TODO: create contract, node and operator in db and use it here
     let req_data = ReportNodeReq {
-        admin_pubkey: get_pub_key().unwrap(),
+        admin_pubkey: pubkey,
         node_pubkey: String::from("node_pubkey"),
         contract: String::from("uuid"),
         reason: String::from("reason"),
     };
 
-    let report_error = client.report_node(sign_request(req_data).unwrap()).await.err().unwrap();
+    let report_error = client.report_node(key.sign_request(req_data).unwrap()).await.err().unwrap();
 
+    println!("Report error: {:?}", report_error);
     assert_eq!(report_error.message(), "No contract found by this ID.");
 
     // verify report in db
@@ -56,14 +61,16 @@ async fn test_report_node() {
 #[tokio::test]
 // TODO: register some operators before testing this
 async fn test_list_operators() {
-    let _ = prepare_test_db().await;
+    prepare_test_db().await;
 
     let channel = run_service_for_stream().await;
 
     let mut client = BrainGeneralCliClient::new(channel);
 
+    let key = Key::new();
+
     let mut grpc_stream =
-        client.list_operators(sign_request(Empty {}).unwrap()).await.unwrap().into_inner();
+        client.list_operators(key.sign_request(Empty {}).unwrap()).await.unwrap().into_inner();
 
     let mut operators = Vec::new();
     while let Some(stream_update) = grpc_stream.next().await {
@@ -83,19 +90,19 @@ async fn test_list_operators() {
 #[tokio::test]
 // TODO: create vm for this user before testing this
 async fn test_list_vm_contracts() {
-    let _ = prepare_test_db().await;
+    prepare_test_db().await;
 
     let channel = run_service_for_stream().await;
     let mut client = BrainVmCliClient::new(channel);
 
-    let req_data = ListVmContractsReq {
+    let key = Key::new();
-        wallet: get_pub_key().unwrap(),
+    let pubkey = key.pubkey.clone();
-        uuid: String::from("uuid"),
+
-        as_operator: false,
+    let req_data =
-    };
+        ListVmContractsReq { wallet: pubkey, uuid: String::from("uuid"), as_operator: false };
 
     let mut grpc_stream =
-        client.list_vm_contracts(sign_request(req_data).unwrap()).await.unwrap().into_inner();
+        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 {