testnet/brain
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

test with new keys

Browse Source 
create new keys for each test
deleted static key
This commit is contained in:
Noor 2025-04-28 20:28:11 +05:30
parent c74eab51ef
commit c424d07cc3
Signed by: noormohammedb
GPG Key ID: D83EFB8B3B967146
6 changed files with 61 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.lock generated
View File

@ -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",

3
Cargo.toml
View File

@ -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"

9
tests/common/prepare_test_env.rs
View File

@ -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
});

57
tests/common/test_utils.rs
View File

@ -4,38 +4,35 @@ 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)
pub struct Key {
pub sg_key: SigningKey,
pub pubkey: String,
}
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)
}
impl 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 get_pub_key() -> Result<String> {
let key = get_signing_key()?;
Ok(bs58::encode(key.verifying_key().to_bytes()).into_string())
}
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 = self.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);
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())
Ok(req)
}
pub fn try_sign_message(&self, message: &str) -> Result<String> {
let key = self.sg_key.clone();
Ok(bs58::encode(key.sign(message.as_bytes()).to_bytes()).into_string())
}
}

1
tests/fixtures/secret_detee_wallet_key vendored
View File

@ -1 +0,0 @@
9RBoFzqSfMVjQmmCbnMhfNGxGEdRmTyb9eF4wDdRVX6f

39
tests/grpcs_test.rs
View File

@ -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 req_data = Pubkey { pubkey: pubkey.clone() };
let key = Key::new();
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 {
wallet: get_pub_key().unwrap(),
uuid: String::from("uuid"),
as_operator: false,
};
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(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 {