refactor(vrd): 🎨 improved log_entry_async and updated unit tests

src/lib.rs

@@ -158,9 +158,7 @@ pub fn create_log_entry(
 }
 
 /// Log an entry asynchronously.
-pub async fn log_entry_async(entry: Log) {
-    entry
-        .log()
-        .await
-        .unwrap_or_else(|e| eprintln!("Failed to log entry: {}", e));
+pub async fn log_entry_async(entry: Log) -> Result<(), Box<dyn std::error::Error>> {
+    entry.log().await?;
+    Ok(())
 }

src/main.rs

@@ -21,7 +21,7 @@
 //!
 //! ```toml
 //! [dependencies]
-//! vrd = "0.1.0"
+//! vrd = "0.0.1"
 //! ```
 //!
 //! Then, use the library in your Rust code:
@@ -75,7 +75,16 @@ fn main() {
             &error_message,
         );
 
-        runtime.block_on(async { log_entry_async(log_entry).await });
+        match runtime.block_on(async { log_entry_async(log_entry).await }) {
+            Ok(_) => {
+                // Logging successful
+                println!("Error logged successfully.");
+            }
+            Err(e) => {
+                // Logging failed
+                eprintln!("Failed to log error: {}", e);
+            }
+        }
 
         process::exit(1);
     }

tests/test_main.rs

@@ -6,17 +6,22 @@
 #[cfg(test)]
 mod tests {
     use rlg::{log_format::LogFormat, log_level::LogLevel};
-    use vrd::create_log_entry;
+    use uuid::Uuid;
+    use vrd::{create_log_entry, log_entry_async};
 
+    // Test creating a log entry
     #[test]
     fn test_create_log_entry() {
+        // Arrange
         let uuid = "test-uuid";
         let iso = "2023-06-10T12:34:56Z";
         let level = LogLevel::INFO;
         let message = "Test log message";
 
+        // Act
         let log_entry = create_log_entry(uuid, iso, level, message);
 
+        // Assert
         assert_eq!(log_entry.session_id, uuid);
         assert_eq!(log_entry.time, iso);
         assert_eq!(log_entry.level.to_string(), "INFO");
@@ -25,18 +30,37 @@ mod tests {
         assert_eq!(log_entry.format, LogFormat::JSON);
     }
 
+    // Test logging asynchronously
     #[tokio::test]
     async fn test_log_entry_async() {
+        // Arrange
         let uuid = "test-uuid";
         let iso = "2023-06-10T12:34:56Z";
         let level = LogLevel::INFO;
         let message = "Test log message";
+
         let log_entry = create_log_entry(uuid, iso, level, message);
 
+        // Act
+        let result = log_entry_async(log_entry).await;
+
+        // Assert
         // Assert that the log entry was logged successfully
-        assert!(log_entry.session_id == "test-uuid");
-        assert!(log_entry.time == "2023-06-10T12:34:56Z");
-        assert!(log_entry.level == LogLevel::INFO);
-        assert!(message == "Test log message");
+        assert!(result.is_ok());
+    }
+
+    // Test UUID generation
+    #[test]
+    fn test_uuid_generation() {
+        // Act
+        // Test generating multiple UUIDs
+        let uuid1 = Uuid::new_v4().to_string();
+        let uuid2 = Uuid::new_v4().to_string();
+
+        // Assert
+        // Ensure UUIDs are generated successfully and are unique
+        assert!(!uuid1.is_empty());
+        assert!(!uuid2.is_empty());
+        assert_ne!(uuid1, uuid2);
     }
 }