Skip to content
This repository has been archived by the owner on Jun 6, 2024. It is now read-only.

Commit

Permalink
add config and db tests
Browse files Browse the repository at this point in the history
  • Loading branch information
@SimranMakhija7
SimranMakhija7 committed May 2, 2024
1 parent 6707ffb commit be460fd
Show file tree
Hide file tree
Showing 2 changed files with 100 additions and 135 deletions.
29 changes: 29 additions & 0 deletions src/config/parameters.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -11,3 +11,32 @@ pub fn get(parameter: &str) -> String {
.expect(&format!("{} is not defined in the environment", parameter));
env_parameter
}

#[cfg(test)]
mod tests {
use super::*;
use std::env;

#[test]
fn test_init() {
// This test checks if the .env file is loaded correctly
init();
assert!(dotenv::var("PORT").is_ok());
}

#[test]
fn test_get() {
// This test checks if the get function correctly retrieves an environment variable
init();
env::set_var("TEST_ENV_VAR", "123");
assert_eq!(get("TEST_ENV_VAR"), "123");
}

#[test]
#[should_panic(expected = "TEST_ENV_VAR_UNDEFINED is not defined in the environment")]
fn test_get_undefined() {
// This test checks if the get function correctly panics when trying to retrieve an undefined environment variable
init();
get("TEST_ENV_VAR_UNDEFINED");
}
}
206 changes: 71 additions & 135 deletions src/database/database.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -138,140 +138,76 @@ impl Database {
}
}

// #[cfg(test)]
// mod tests {
// use super::*;
// use tempfile::tempdir;

// #[test]
// fn test_open() {
// let dir = tempdir().unwrap();
// let db = Database::open(dir.path());
// assert!(db.is_ok());
// }

// #[test]
// fn test_insert_and_get() {
// let dir = tempdir().unwrap();
// let db = Database::open(dir.path()).unwrap();
// let key = "test_key";
// let value = "test_value";

// // Test insert
// let insert_result = db.insert("NamespaceData", &key, &value);
// assert!(insert_result.is_ok());

// // Test get
// let get_result: Result<Option<String>, _> = db.get("NamespaceData", &key);
// assert!(get_result.is_ok());
// assert_eq!(get_result.unwrap().unwrap(), value);
// }

// #[test]
// fn test_delete() {
// let dir = tempdir().unwrap();
// let db = Database::open(dir.path()).unwrap();
// let key = "test_key";
// let value = "test_value";

// // Insert a key-value pair
// db.insert("NamespaceData", &key, &value).unwrap();

// // Delete the key
// let delete_result = db.delete("NamespaceData", &key);
// assert!(delete_result.is_ok());

// // Try to get the deleted key
// let get_result: Result<Option<String>, _> = db.get("NamespaceData", &key);
// assert!(get_result.is_ok());
// assert!(get_result.unwrap().is_none());
// }

// #[test]
// fn test_insert_and_get_nonexistent_cf() {
// let dir = tempdir().unwrap();
// let db = Database::open(dir.path()).unwrap();
// let key = "test_key";
// let value = "test_value";

// // Test insert with nonexistent column family
// let insert_result = db.insert("NonexistentCF", &key, &value);
// assert!(insert_result.is_err());

// // Test get with nonexistent column family
// let get_result: Result<Option<String>, _> = db.get("NonexistentCF", &key);
// assert!(get_result.is_err());
// }

// #[test]
// fn test_get_nonexistent_key() {
// let dir = tempdir().unwrap();
// let db = Database::open(dir.path()).unwrap();

// // Test get with nonexistent key
// let get_result: Result<Option<String>, _> = db.get("NamespaceData", &"nonexistent_key");
// assert!(get_result.is_ok());
// assert!(get_result.unwrap().is_none());
// }

// #[test]
// fn test_delete_nonexistent_key() {
// let dir = tempdir().unwrap();
// let db = Database::open(dir.path()).unwrap();

// // Test delete with nonexistent key
// let delete_result = db.delete("NamespaceData", &"nonexistent_key");
// assert!(delete_result.is_ok());
// }

// #[test]
// fn test_insert_and_get_empty_key() {
// let dir = tempdir().unwrap();
// let db = Database::open(dir.path()).unwrap();
// let key = "";
// let value = "test_value";

// // Test insert with empty key
// let insert_result = db.insert("NamespaceData", &key, &value);
// assert!(insert_result.is_ok());

// // Test get with empty key
// let get_result: Result<Option<String>, _> = db.get("NamespaceData", &key);
// assert!(get_result.is_ok());
// assert_eq!(get_result.unwrap().unwrap(), value);
// }

// #[test]
// fn test_insert_and_get_empty_value() {
// let dir = tempdir().unwrap();
// let db = Database::open(dir.path()).unwrap();
// let key = "test_key";
// let value = "";

// // Test insert with empty value
// let insert_result = db.insert("NamespaceData", &key, &value);
// assert!(insert_result.is_ok());

// // Test get with empty value
// let get_result: Result<Option<String>, _> = db.get("NamespaceData", &key);
// assert!(get_result.is_ok());
// assert_eq!(get_result.unwrap().unwrap(), value);
// }

// #[test]
// fn test_insert_and_get_large_data() {
// let dir = tempdir().unwrap();
// let db = Database::open(dir.path()).unwrap();
// let key = "test_key";
// let value = "a".repeat(1_000_000);
#[cfg(test)]
mod tests {
use super::*;
use tempfile::tempdir;

#[test]
fn test_database_operations() {
let dir = tempdir().unwrap();
let db_path = dir.path();

// Test open
let db = Database::open(db_path).unwrap();

// Test insert
let key : String = "key1".to_string();
let value = "value1";
db.insert("NamespaceData", &key, &value).unwrap();

// Test get
let retrieved_value: Option<String> = db.get("NamespaceData", &key).unwrap();
assert_eq!(retrieved_value, Some(value.to_string()));

// Test update
let updated_value = "updated_value1";
db.update("NamespaceData", &key, &updated_value).unwrap();
let retrieved_value: Option<String> = db.get("NamespaceData", &key).unwrap();
assert_eq!(retrieved_value, Some(updated_value.to_string()));

// Test delete
db.delete("NamespaceData", &key).unwrap();
let retrieved_value: Option<String> = db.get("NamespaceData", &key).unwrap();
assert_eq!(retrieved_value, None);
}

// // Test insert with large data
// let insert_result = db.insert("NamespaceData", &key, &value);
// assert!(insert_result.is_ok());
#[test]
fn test_database_operations_negative_paths() {
let dir = tempdir().unwrap();
let db_path = dir.path();

// Test open
let db = Database::open(db_path).unwrap();

// Test get with non-existing key
let non_existing_key = "non_existing_key".to_string();
let retrieved_value: Option<String> = db.get("NamespaceData", &non_existing_key).unwrap();
assert_eq!(retrieved_value, None);

// Test update with non-existing key
let updated_value = "updated_value1";
db.update("NamespaceData", &non_existing_key, &updated_value).unwrap();
let retrieved_value: Option<String> = db.get("NamespaceData", &non_existing_key).unwrap();
assert_eq!(retrieved_value, Some(updated_value.to_string()));

// Test delete with non-existing key
db.delete("NamespaceData", &non_existing_key).unwrap();
let retrieved_value: Option<String> = db.get("NamespaceData", &non_existing_key).unwrap();
assert_eq!(retrieved_value, None);

// Test operations with non-existing column family
let non_existing_cf = "non_existing_cf";
let key = "key1".to_string();
let value = "value1";
let result = db.insert(non_existing_cf, &key, &value);
assert!(result.is_err());
let result: Result<Option<String>, _> = db.get(non_existing_cf, &key);
assert!(result.is_err());
let result = db.update(non_existing_cf, &key, &value);
assert!(result.is_err());
let result = db.delete(non_existing_cf, &key);
assert!(result.is_err());
}
}

// // Test get with large data
// let get_result: Result<Option<String>, _> = db.get("NamespaceData", &key);
// assert!(get_result.is_ok());
// assert_eq!(get_result.unwrap().unwrap(), value);
// }
// }

0 comments on commit be460fd

Please sign in to comment.