noormohammedb/hacker-challenge-sgx-general
1
0
Fork 0
forked from general/hacker-challenge
Code Pull Requests Activity

added more tests

Browse Source
This commit is contained in:
ghe0 2024-08-23 01:01:21 +03:00
parent 87c04454ad
commit dfe37b27cf
Signed by: ghe0
GPG Key ID: 451028EE56A0FBB4
2 changed files with 93 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/datastore.rs
View File

@ -290,7 +290,7 @@ mod tests {
use std::time::{SystemTime, UNIX_EPOCH};
#[test]
fn test_node_info_creation() {
fn node_info_creation() {
let keypair = SigningKey::generate(&mut OsRng);
let node_info = NodeInfo {
pubkey: keypair.verifying_key(),
@ -304,7 +304,7 @@ mod tests {
}
#[test]
fn test_store_creation() {
fn store_creation() {
let store = Store {
nodes: DashMap::new(),
conns: DashSet::new(),
@ -317,7 +317,7 @@ mod tests {
}
#[test]
fn test_signing_error_from_hex_error() {
fn signing_error_from_hex_error() {
let hex_error: Result<(), hex::FromHexError> =
Err(hex::FromHexError::InvalidHexCharacter { c: 'a', index: 0 });
let signing_error: SigningError = hex_error.unwrap_err().into();
@ -329,7 +329,7 @@ mod tests {
}
#[tokio::test]
async fn test_sign_message_with_key() {
async fn sign_message_with_key() {
let keypair = SigningKey::generate(&mut OsRng);
let pubkey_hex = hex::encode(keypair.verifying_key().as_bytes());
let store = Store {
@ -349,7 +349,7 @@ mod tests {
}
#[tokio::test]
async fn test_process_node_update() {
async fn process_node_update() {
let keypair = SigningKey::generate(&mut OsRng);
let node_update = NodeUpdate {
ip: "127.0.0.1".to_string(),
@ -377,7 +377,7 @@ mod tests {
}
#[tokio::test]
async fn test_get_full_node_list() {
async fn get_full_node_list() {
let keypair = SigningKey::generate(&mut OsRng);
let node_info = NodeInfo {
pubkey: keypair.verifying_key(),

137
src/persistence.rs
View File

@ -116,6 +116,7 @@ mod tests {
use super::*;
use ed25519_dalek::SigningKey;
use rand::rngs::OsRng;
use rand::Rng;
use std::io::Result;
use tokio::fs::remove_file;
use tokio::io::AsyncWriteExt;
@ -125,6 +126,7 @@ mod tests {
TEST_FILE_PREFIX.to_string() + function
}
async fn setup_test_file(function: &str) -> Result<FileManager> {
let _ = tokio::fs::create_dir_all(".tmp").await;
let path = get_test_file_name(function);
let mut file = File::create(path.clone()).await?;
file.flush().await?;
@ -133,7 +135,7 @@ mod tests {
}
#[test]
fn test_node_to_bytes_and_back() {
fn node_round_trip() {
let keypair = SigningKey::generate(&mut OsRng);
let original_node = Node {
@ -166,36 +168,35 @@ mod tests {
#[tokio::test]
async fn setup_file_manager() {
match setup_test_file("setup_file_manager").await {
let function_name = "setup_file_manager";
let _ = match setup_test_file(function_name).await {
Err(e) => {
panic!("Could not init File Manager: {}", e);
}
_ => {}
_ => remove_file(get_test_file_name(function_name)).await,
};
}
fn get_random_node() -> Node {
let keypair = SigningKey::generate(&mut OsRng);
let mut rng = rand::thread_rng();
let ipv4 = Ipv4Addr::new(rng.gen(), rng.gen(), rng.gen(), rng.gen());
Node {
ip: ipv4,
keypair: keypair.clone(),
joined_at: SystemTime::now(),
}
}
#[tokio::test]
async fn test_file_manager_append_and_retrieve_node() -> Result<()> {
let function_name = "test_file_manager_append_and_retrieve_node";
async fn append_and_retrieve() -> Result<()> {
let function_name = "append_and_retrieve";
let manager = setup_test_file(function_name).await?;
let keypair = SigningKey::generate(&mut OsRng);
let node = Node {
ip: "192.168.1.1".parse().unwrap(),
keypair: keypair.clone(),
joined_at: SystemTime::now(),
};
manager.append_node(node.clone()).await.unwrap();
let retrieved_node = manager.get_node_by_id(0).await.unwrap();
let node = get_random_node();
manager.append_node(node.clone()).await?;
let retrieved_node = manager.get_node_by_id(0).await?;
assert_eq!(node.ip_as_string(), retrieved_node.ip_as_string());
assert_eq!(
node.keypair.to_keypair_bytes(),
retrieved_node.keypair.to_keypair_bytes()
);
assert_eq!(node.keypair, retrieved_node.keypair);
assert_eq!(
node.joined_at.duration_since(UNIX_EPOCH).unwrap().as_secs(),
retrieved_node
@ -205,49 +206,85 @@ mod tests {
.as_secs()
);
remove_file(get_test_file_name(function_name)).await?;
Ok(())
}
#[tokio::test]
async fn test_file_manager_multiple_nodes() -> Result<()> {
let function_name = "test_file_manager_multiple_nodes";
async fn append_and_retrieve_multiple() -> Result<()> {
let function_name = "append_and_retrieve_multiple";
let manager = setup_test_file(function_name).await?;
let keypair1 = SigningKey::generate(&mut OsRng);
let node1 = Node {
ip: "192.168.1.1".parse().unwrap(),
keypair: keypair1.clone(),
joined_at: SystemTime::now(),
};
let keypair2 = SigningKey::generate(&mut OsRng);
let node2 = Node {
ip: "10.0.0.1".parse().unwrap(),
keypair: keypair2.clone(),
joined_at: SystemTime::now(),
};
manager.append_node(node1.clone()).await.unwrap();
manager.append_node(node2.clone()).await.unwrap();
let node1 = get_random_node();
let node2 = get_random_node();
manager.append_node(node1.clone()).await?;
manager.append_node(node2.clone()).await?;
let retrieved_node1 = manager.get_node_by_id(0).await?;
let node3 = get_random_node();
manager.append_node(node3.clone()).await.unwrap();
let retrieved_node2 = manager.get_node_by_id(1).await?;
assert_eq!(node1.ip_as_string(), retrieved_node1.ip_as_string());
assert_eq!(
node1.keypair.to_keypair_bytes(),
retrieved_node1.keypair.to_keypair_bytes()
);
assert_eq!(node2.ip_as_string(), retrieved_node2.ip_as_string());
assert_eq!(
node2.keypair.to_keypair_bytes(),
retrieved_node2.keypair.to_keypair_bytes()
);
assert_eq!(node2.keypair, retrieved_node2.keypair);
let retrieved_node3 = manager.get_node_by_id(2).await?;
assert_eq!(node3.ip_as_string(), retrieved_node3.ip_as_string());
assert_eq!(node3.keypair, retrieved_node3.keypair);
remove_file(get_test_file_name(function_name)).await?;
Ok(())
}
#[tokio::test]
async fn append_20_and_retrieve_1_loop() -> Result<()> {
let function_name = "append_20_and_retrieve_1_loop";
let manager = setup_test_file(function_name).await?;
let mut count = 0;
let mut nodes_vec: Vec<Node> = Vec::new();
while count < 100 {
let node = get_random_node();
if count % 10 == 0 {
nodes_vec.push(node.clone());
}
manager.append_node(node).await?;
count += 1;
}
count = 0;
for node in nodes_vec.iter() {
let r_node = manager.get_node_by_id(count * 10).await?;
assert_eq!(node.ip_as_string(), r_node.ip_as_string());
assert_eq!(node.keypair, r_node.keypair);
count += 1;
if count > 3 {
break;
}
}
count = 100;
while count < 500 {
let node = get_random_node();
if count % 10 == 0 {
nodes_vec.push(node.clone());
}
manager.append_node(node).await?;
count += 1;
}
count = 0;
for node in nodes_vec.iter() {
let r_node = manager.get_node_by_id(count * 10).await?;
assert_eq!(node.ip_as_string(), r_node.ip_as_string());
assert_eq!(node.keypair, r_node.keypair);
count += 1;
if count > 49 {
break;
}
}
remove_file(get_test_file_name(function_name)).await?;
Ok(())
}
}