raven
a8755bd3de
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
97 lines
2.5 KiB
Rust
97 lines
2.5 KiB
Rust
use packet_service::bufferpool::BufferPool;
|
|
use std::sync::Arc;
|
|
|
|
#[tokio::test]
|
|
async fn test_buffer_pool_creation() {
|
|
let pool_size = 5;
|
|
let pool = BufferPool::new(pool_size);
|
|
|
|
// Verify we can acquire the expected number of buffers
|
|
for _ in 0..pool_size {
|
|
let buffer = pool.acquire().await;
|
|
assert!(buffer.is_some());
|
|
}
|
|
|
|
// The next acquire should return None since all buffers are in use
|
|
let buffer = pool.acquire().await;
|
|
assert!(buffer.is_none());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_buffer_pool_release() {
|
|
let pool_size = 3;
|
|
let pool = BufferPool::new(pool_size);
|
|
|
|
// Acquire all buffers
|
|
let mut buffers = Vec::new();
|
|
for _ in 0..pool_size {
|
|
let buffer = pool.acquire().await.unwrap();
|
|
buffers.push(buffer);
|
|
}
|
|
|
|
// Release one buffer
|
|
let buffer = buffers.pop().unwrap();
|
|
pool.release(buffer).await;
|
|
|
|
// We should be able to acquire one buffer now
|
|
let buffer = pool.acquire().await;
|
|
assert!(buffer.is_some());
|
|
|
|
// But not two
|
|
let buffer = pool.acquire().await;
|
|
assert!(buffer.is_none());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_buffer_pool_concurrent_access() {
|
|
let pool_size = 10;
|
|
let pool = Arc::new(BufferPool::new(pool_size));
|
|
|
|
// Spawn multiple tasks to acquire and release buffers
|
|
let mut handles = Vec::new();
|
|
|
|
for i in 0..pool_size {
|
|
let pool_clone = pool.clone();
|
|
let handle = tokio::spawn(async move {
|
|
// Acquire a buffer
|
|
let mut buffer = pool_clone.acquire().await.unwrap();
|
|
|
|
// Write some data to the buffer
|
|
buffer[0] = i as u8;
|
|
|
|
// Simulate some work
|
|
tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
|
|
|
|
// Release the buffer
|
|
pool_clone.release(buffer).await;
|
|
});
|
|
|
|
handles.push(handle);
|
|
}
|
|
|
|
// Wait for all tasks to complete
|
|
for handle in handles {
|
|
handle.await.unwrap();
|
|
}
|
|
|
|
// All buffers should be available again
|
|
for _ in 0..pool_size {
|
|
let buffer = pool.acquire().await;
|
|
assert!(buffer.is_some());
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_buffer_pool_buffer_size() {
|
|
let pool = BufferPool::new(1);
|
|
|
|
// Acquire a buffer
|
|
let buffer = pool.acquire().await.unwrap();
|
|
|
|
// Buffer should be large enough for maximum packet size
|
|
assert!(buffer.len() >= 0xFFF);
|
|
|
|
// Release the buffer
|
|
pool.release(buffer).await;
|
|
}
|