Add comprehensive documentation and unit tests

Documentation:
- Add detailed README files for all services (auth, character, database, launcher, packet, utils, world)
- Create API documentation for the database service with detailed endpoint specifications
- Document database schema and relationships
- Add service architecture overviews and configuration instructions

Unit Tests:
- Implement comprehensive test suite for database repositories (user, character, session)
- Add gRPC service tests for database interactions
- Create tests for packet service components (bufferpool, connection, packets)
- Add utility service tests (health check, logging, load balancer, redis cache, service discovery)
- Implement auth service user tests
- Add character service tests

Code Structure:
- Reorganize test files into a more consistent structure
- Create a dedicated tests crate for integration testing
- Add test helpers and mock implementations for easier testing

tests/database-service/get_user.rs

@@ -0,0 +1,78 @@
+use database_service::users::{User, UserRepository};
+use sqlx::postgres::PgPoolOptions;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+use utils::redis_cache::RedisCache;
+
+// Helper function to create a test database pool
+async fn setup_test_pool() -> Result<sqlx::PgPool, sqlx::Error> {
+    let database_url = std::env::var("TEST_DATABASE_URL")
+        .unwrap_or_else(|_| "postgres://postgres:postgres@localhost:5432/test_db".to_string());
+
+    PgPoolOptions::new()
+        .max_connections(5)
+        .connect(&database_url)
+        .await
+}
+
+// Helper function to create a mock Redis cache
+fn setup_test_cache() -> Arc<Mutex<RedisCache>> {
+    let redis_url = std::env::var("TEST_REDIS_URL")
+        .unwrap_or_else(|_| "redis://localhost:6379".to_string());
+
+    Arc::new(Mutex::new(RedisCache::new(&redis_url)))
+}
+
+// Helper function to create a test user in the database
+async fn create_test_user(pool: &sqlx::PgPool) -> i32 {
+    let result = sqlx::query!(
+        r#"
+        INSERT INTO "user" (name, email, role, "createdAt", "updatedAt")
+        VALUES ('test_user', 'test@example.com', 'user', NOW(), NOW())
+        RETURNING id
+        "#
+    )
+    .fetch_one(pool)
+    .await
+    .expect("Failed to create test user");
+
+    result.id
+}
+
+// Helper function to clean up test data
+async fn cleanup_test_user(pool: &sqlx::PgPool, user_id: i32) {
+    sqlx::query!(r#"DELETE FROM "user" WHERE id = $1"#, user_id)
+        .execute(pool)
+        .await
+        .expect("Failed to delete test user");
+}
+
+#[tokio::test]
+async fn test_get_user() {
+    // Skip test if database connection is not available
+    let pool = match setup_test_pool().await {
+        Ok(pool) => pool,
+        Err(_) => {
+            println!("Skipping test_get_user: Test database not available");
+            return;
+        }
+    };
+
+    let cache = setup_test_cache();
+    let repo = UserRepository::new(pool.clone(), cache);
+
+    // Create test user
+    let user_id = create_test_user(&pool).await;
+
+    // Test the get_user_by_id function
+    let user = repo.get_user_by_id(user_id).await.unwrap();
+
+    // Validate the user
+    assert_eq!(user.id, user_id);
+    assert_eq!(user.name, "test_user");
+    assert_eq!(user.email, "test@example.com");
+    assert_eq!(user.role, "user");
+
+    // Cleanup
+    cleanup_test_user(&pool, user_id).await;
+}

tests/database-service/grpc_get_user.rs

@@ -0,0 +1,92 @@
+use database_service::db::Database;
+use database_service::grpc::database_service::MyDatabaseService;
+use database_service::grpc::user_service_server::UserService;
+use database_service::grpc::{GetUserRequest, GetUserResponse};
+use sqlx::postgres::PgPoolOptions;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+use tonic::{Request, Response, Status};
+use utils::redis_cache::RedisCache;
+
+// Helper function to create a test database pool
+async fn setup_test_pool() -> sqlx::PgPool {
+    let database_url = std::env::var("TEST_DATABASE_URL")
+        .unwrap_or_else(|_| "postgres://postgres:postgres@localhost:5432/test_db".to_string());
+
+    PgPoolOptions::new()
+        .max_connections(5)
+        .connect(&database_url)
+        .await
+        .expect("Failed to create test database pool")
+}
+
+// Helper function to create a mock Redis cache
+fn setup_test_cache() -> Arc<Mutex<RedisCache>> {
+    let redis_url = std::env::var("TEST_REDIS_URL")
+        .unwrap_or_else(|_| "redis://localhost:6379".to_string());
+
+    Arc::new(Mutex::new(RedisCache::new(&redis_url)))
+}
+
+// Helper function to create a test user in the database
+async fn create_test_user(pool: &sqlx::PgPool) -> i32 {
+    let result = sqlx::query!(
+        r#"
+        INSERT INTO "user" (name, email, role, "createdAt", "updatedAt")
+        VALUES ('test_user', 'test@example.com', 'user', NOW(), NOW())
+        RETURNING id
+        "#
+    )
+    .fetch_one(pool)
+    .await
+    .expect("Failed to create test user");
+
+    result.id
+}
+
+// Helper function to clean up test data
+async fn cleanup_test_user(pool: &sqlx::PgPool, user_id: i32) {
+    sqlx::query!(r#"DELETE FROM "user" WHERE id = $1"#, user_id)
+        .execute(pool)
+        .await
+        .expect("Failed to delete test user");
+}
+
+#[tokio::test]
+async fn test_grpc_get_user() {
+    // Skip test if database connection is not available
+    let pool_result = setup_test_pool().await;
+    let pool = match pool_result {
+        Ok(pool) => pool,
+        Err(_) => {
+            println!("Skipping test_grpc_get_user: Test database not available");
+            return;
+        }
+    };
+
+    let cache = setup_test_cache();
+
+    // Create test user
+    let user_id = create_test_user(&pool).await;
+
+    // Create the database service
+    let db = Arc::new(Database::new(pool.clone(), cache));
+    let service = MyDatabaseService { db };
+
+    // Create a gRPC request
+    let request = Request::new(GetUserRequest {
+        user_id,
+    });
+
+    // Call the service
+    let response = service.get_user(request).await.unwrap().into_inner();
+
+    // Validate the response
+    assert_eq!(response.user_id, user_id);
+    assert_eq!(response.username, "test_user");
+    assert_eq!(response.email, "test@example.com");
+    assert_eq!(response.role, "user");
+
+    // Cleanup
+    cleanup_test_user(&pool, user_id).await;
+}

tests/database-service/integration.rs

@@ -0,0 +1,12 @@
+#[cfg(test)]
+mod tests {
+    use dotenv::dotenv;
+
+    #[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);
+    }
+}

tests/database-service/mock_tests.rs

@@ -0,0 +1,137 @@
+use database_service::users::User;
+use mockall::predicate::*;
+use mockall::predicate::eq;
+use mockall::mock;
+use std::sync::Arc;
+use chrono::NaiveDateTime;
+
+// Mock the UserRepository
+mock! {
+    pub UserRepository {
+        fn get_user_by_id(&self, user_id: i32) -> Result<User, sqlx::Error>;
+        fn get_user_by_username(&self, username: &str) -> Result<User, sqlx::Error>;
+        fn get_user_by_email(&self, email: &str) -> Result<User, sqlx::Error>;
+    }
+}
+
+// Mock the CharacterRepository
+mock! {
+    pub CharacterRepository {
+        fn get_character_by_id(&self, character_id: i32) -> Result<database_service::characters::Character, sqlx::Error>;
+        fn get_character_list(&self, user_id: String) -> Result<Vec<database_service::characters::Character>, sqlx::Error>;
+        fn create_character(
+            &self,
+            user_id: String,
+            name: &str,
+            inventory: serde_json::Value,
+            skills: serde_json::Value,
+            stats: serde_json::Value,
+            looks: serde_json::Value,
+            position: serde_json::Value,
+        ) -> Result<i32, sqlx::Error>;
+        fn delete_character(&self, character_id: i32, delete_type: i32) -> Result<i64, sqlx::Error>;
+    }
+}
+
+// Mock the SessionRepository
+mock! {
+    pub SessionRepository {
+        fn get_session(&self, session_id: &str) -> Result<database_service::sessions::Session, sqlx::Error>;
+        fn refresh_session(&self, session_id: &str) -> Result<database_service::sessions::Session, sqlx::Error>;
+    }
+}
+
+// Mock the Database struct
+struct MockDatabase<U, C, S> {
+    user_repo: Arc<U>,
+    character_repo: Arc<C>,
+    session_repo: Arc<S>,
+}
+
+type MockDatabaseWithMocks = MockDatabase<MockUserRepository, MockCharacterRepository, MockSessionRepository>;
+
+#[tokio::test]
+async fn test_user_repository_mock() {
+    // Create a mock UserRepository
+    let mut mock_user_repo = MockUserRepository::new();
+
+    // Set up expectations
+    mock_user_repo
+        .expect_get_user_by_id()
+        .with(eq(123))
+        .times(1)
+        .returning(|_| {
+            Ok(User {
+                id: 123,
+                name: "mock_user".to_string(),
+                email: "mock@example.com".to_string(),
+                role: "user".to_string(),
+                created_at: NaiveDateTime::from_timestamp_opt(0, 0).unwrap(),
+                updated_at: NaiveDateTime::from_timestamp_opt(0, 0).unwrap(),
+            })
+        });
+
+    // Test the mock
+    let user = mock_user_repo.get_user_by_id(123).unwrap();
+    assert_eq!(user.id, 123);
+    assert_eq!(user.name, "mock_user");
+    assert_eq!(user.email, "mock@example.com");
+}
+
+#[tokio::test]
+async fn test_character_repository_mock() {
+    // Create a mock CharacterRepository
+    let mut mock_character_repo = MockCharacterRepository::new();
+
+    // Set up expectations
+    mock_character_repo
+        .expect_get_character_by_id()
+        .with(eq(456))
+        .times(1)
+        .returning(|_| {
+            Ok(database_service::characters::Character {
+                id: 456,
+                user_id: "123".to_string(),
+                name: "mock_character".to_string(),
+                money: 1000,
+                inventory: serde_json::json!({}),
+                stats: serde_json::json!({}),
+                skills: serde_json::json!({}),
+                looks: serde_json::json!({}),
+                position: serde_json::json!({}),
+                created_at: NaiveDateTime::from_timestamp_opt(0, 0).unwrap(),
+                updated_at: NaiveDateTime::from_timestamp_opt(0, 0).unwrap(),
+                deleted_at: None,
+                is_active: true,
+            })
+        });
+
+    // Test the mock
+    let character = mock_character_repo.get_character_by_id(456).unwrap();
+    assert_eq!(character.id, 456);
+    assert_eq!(character.name, "mock_character");
+    assert_eq!(character.user_id, "123");
+}
+
+#[tokio::test]
+async fn test_session_repository_mock() {
+    // Create a mock SessionRepository
+    let mut mock_session_repo = MockSessionRepository::new();
+
+    // Set up expectations
+    mock_session_repo
+        .expect_get_session()
+        .with(eq("session123"))
+        .times(1)
+        .returning(|_| {
+            Ok(database_service::sessions::Session {
+                id: "session123".to_string(),
+                user_id: "123".to_string(),
+            })
+        });
+
+    // Test the mock
+    let session = mock_session_repo.get_session("session123").unwrap();
+    assert_eq!(session.id, "session123");
+    assert_eq!(session.user_id, "123");
+}

tests/database-service/redis_cache.rs

@@ -0,0 +1,16 @@
+#[tokio::test]
+async fn test_redis_cache() {
+    // dotenv().ok();
+    // let redis_url = std::env::var("REDIS_URL").unwrap_or_else(|_| "redis://127.0.0.1:6379".to_string());
+    // 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()));
+}

tests/database-service/test_helpers.rs

@@ -0,0 +1,151 @@
+use sqlx::postgres::PgPoolOptions;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+use utils::redis_cache::RedisCache;
+
+// Helper function to create a test database pool
+pub async fn setup_test_pool() -> Result<sqlx::PgPool, sqlx::Error> {
+    let database_url = std::env::var("TEST_DATABASE_URL")
+        .unwrap_or_else(|_| "postgres://postgres:postgres@localhost:5432/test_db".to_string());
+    
+    PgPoolOptions::new()
+        .max_connections(5)
+        .connect(&database_url)
+        .await
+}
+
+// Helper function to create a mock Redis cache
+pub fn setup_test_cache() -> Arc<Mutex<RedisCache>> {
+    let redis_url = std::env::var("TEST_REDIS_URL")
+        .unwrap_or_else(|_| "redis://localhost:6379".to_string());
+    
+    Arc::new(Mutex::new(RedisCache::new(&redis_url)))
+}
+
+// Helper function to create a test user in the database
+pub async fn create_test_user(pool: &sqlx::PgPool, name: &str, email: &str) -> i32 {
+    let result = sqlx::query!(
+        r#"
+        INSERT INTO "user" (name, email, role, "createdAt", "updatedAt")
+        VALUES ($1, $2, 'user', NOW(), NOW())
+        RETURNING id
+        "#,
+        name,
+        email
+    )
+    .fetch_one(pool)
+    .await
+    .expect("Failed to create test user");
+
+    result.id
+}
+
+// Helper function to create a test character in the database
+pub async fn create_test_character(
+    pool: &sqlx::PgPool, 
+    user_id: i32, 
+    name: &str
+) -> i32 {
+    let inventory = serde_json::json!({
+        "items": [],
+        "capacity": 100
+    });
+    
+    let stats = serde_json::json!({
+        "strength": 10,
+        "dexterity": 10,
+        "intelligence": 10,
+        "vitality": 10
+    });
+    
+    let skills = serde_json::json!({
+        "skills": []
+    });
+    
+    let looks = serde_json::json!({
+        "race": 1,
+        "gender": 0,
+        "hair": 1,
+        "face": 1
+    });
+    
+    let position = serde_json::json!({
+        "mapId": 1,
+        "x": 100.0,
+        "y": 100.0,
+        "z": 0.0
+    });
+
+    let result = sqlx::query!(
+        r#"
+        INSERT INTO character (
+            "userId", name, money, inventory, stats, skills, looks, position, 
+            "createdAt", "updatedAt", "isActive"
+        )
+        VALUES ($1, $2, 0, $3, $4, $5, $6, $7, NOW(), NOW(), true)
+        RETURNING id
+        "#,
+        user_id,
+        name,
+        inventory,
+        stats,
+        skills,
+        looks,
+        position
+    )
+    .fetch_one(pool)
+    .await
+    .expect("Failed to create test character");
+
+    result.id
+}
+
+// Helper function to create a test session in the database
+pub async fn create_test_session(pool: &sqlx::PgPool, user_id: i32) -> String {
+    let session_id = uuid::Uuid::new_v4().to_string();
+    
+    sqlx::query!(
+        r#"
+        INSERT INTO session (id, "userId", "createdAt", "expiresAt")
+        VALUES ($1, $2, NOW(), NOW() + INTERVAL '1 hour')
+        "#,
+        session_id,
+        user_id
+    )
+    .execute(pool)
+    .await
+    .expect("Failed to create test session");
+
+    session_id
+}
+
+// Helper function to clean up test user data
+pub async fn cleanup_test_user(pool: &sqlx::PgPool, user_id: i32) {
+    sqlx::query!(r#"DELETE FROM "user" WHERE id = $1"#, user_id)
+        .execute(pool)
+        .await
+        .expect("Failed to delete test user");
+}
+
+// Helper function to clean up test character data
+pub async fn cleanup_test_character(pool: &sqlx::PgPool, character_id: i32) {
+    sqlx::query!(r#"DELETE FROM character WHERE id = $1"#, character_id)
+        .execute(pool)
+        .await
+        .expect("Failed to delete test character");
+}
+
+// Helper function to clean up test session data
+pub async fn cleanup_test_session(pool: &sqlx::PgPool, session_id: &str) {
+    sqlx::query!(r#"DELETE FROM session WHERE id = $1"#, session_id)
+        .execute(pool)
+        .await
+        .expect("Failed to delete test session");
+}
+
+// Helper function to clean up all test data
+pub async fn cleanup_test_data(pool: &sqlx::PgPool, user_id: i32, character_id: i32, session_id: &str) {
+    cleanup_test_session(pool, session_id).await;
+    cleanup_test_character(pool, character_id).await;
+    cleanup_test_user(pool, user_id).await;
+}