- add: initial database and auth services

database-service/tests/get_user.rs

@@ -0,0 +1,30 @@
+use sqlx::{PgPool, Executor};
+use tokio;
+
+#[tokio::test]
+async fn test_get_user() {
+    // Set up a temporary in-memory PostgreSQL database
+    let pool = PgPool::connect("postgres://user:password@localhost/test_database").await.unwrap();
+
+    // Create the test table
+    pool.execute(
+        r#"
+        CREATE TABLE users (
+            user_id TEXT PRIMARY KEY,
+            username TEXT NOT NULL,
+            email TEXT NOT NULL,
+            hashed_password TEXT NOT NULL
+        );
+        INSERT INTO users (user_id, username, email, hashed_password)
+        VALUES ('123', 'test_user', 'test@example.com', 'hashed_password_example');
+        "#,
+    )
+        .await
+        .unwrap();
+
+    // Test the `get_user` function
+    let user = get_user(&pool, "123").await.unwrap();
+    assert_eq!(user.user_id, "123");
+    assert_eq!(user.username, "test_user");
+    assert_eq!(user.email, "test@example.com");
+}

database-service/tests/grpc_get_user.rs

@@ -0,0 +1,25 @@
+use tonic::{Request, Response};
+use database_service::database::database_service_server::DatabaseService;
+use database_service::database::GetUserRequest;
+use database_service::MyDatabaseService;
+
+#[tokio::test]
+async fn test_grpc_get_user() {
+    let pool = setup_test_pool().await; // Set up your test pool
+    let cache = setup_test_cache().await; // Set up mock Redis cache
+
+    let service = MyDatabaseService { pool, cache };
+
+    // Create a mock gRPC request
+    let request = Request::new(GetUserRequest {
+        user_id: 123,
+    });
+
+    // Call the service
+    let response = service.get_user(request).await.unwrap().into_inner();
+
+    // Validate the response
+    assert_eq!(response.user_id, 123);
+    assert_eq!(response.username, "test_user");
+    assert_eq!(response.email, "test@example.com");
+}

database-service/tests/integration.rs

@@ -0,0 +1,14 @@
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use dotenv::dotenv;
+    use database_service::db::Database;
+
+    #[tokio::test]
+    async fn test_health_check() {
+        dotenv().ok();
+        let database_url = std::env::var("DATABASE_URL").unwrap();
+        let db = Database::new(&database_url).await;
+        assert!(db.health_check().await);
+    }
+}

database-service/tests/redis_cache.rs

@@ -0,0 +1,19 @@
+use deadpool_redis::{Config, Pool, Runtime};
+use redis::AsyncCommands;
+use database_service::redis_cache::RedisCache;
+
+#[tokio::test]
+async fn test_redis_cache() {
+    let redis_url = "redis://127.0.0.1:6379";
+    let cache = RedisCache::new(redis_url);
+
+    let key = &"test_key".to_string();
+    let value = "test_value";
+
+    // Test setting a value
+    cache.set(key, &value, 10).await.unwrap();
+
+    // Test getting the value
+    let cached_value: Option<String> = cache.get(key).await.unwrap();
+    assert_eq!(cached_value, Some("test_value".to_string()));
+}