#[cfg(test)]
use std::sync::Arc;
#[cfg(test)]
use std::time::{Duration, Instant};
#[cfg(test)]
use super::config::RateLimiterConfig;
#[cfg(test)]
use super::rate_limiter::RateLimiter;
#[cfg(test)]
use super::throttled_writer::ThrottledWriter;
#[cfg(test)]
use super::token_bucket::TokenBucket;
#[cfg(test)]
use crate::filesystem::disk_writer::{DiskWriter, SeekableDiskWriter};
#[tokio::test]
async fn test_token_bucket_unlimited() {
let tb = TokenBucket::unlimited();
assert!(tb.is_unlimited());
tb.acquire(1024 * 1024 * 1024).await;
assert!(tb.available_tokens() > 0.0);
}
#[tokio::test]
async fn test_token_bucket_basic_acquire() {
let tb = TokenBucket::new(10000, Some(5000));
assert!(!tb.is_unlimited());
let start = Instant::now();
tb.acquire(5000).await;
let elapsed = start.elapsed();
assert!(
elapsed < Duration::from_millis(100),
"burst should be instant: {:?}",
elapsed
);
tb.acquire(6000).await;
let total_elapsed = start.elapsed();
let expected_min = Duration::from_millis(100);
assert!(
total_elapsed >= expected_min.saturating_sub(Duration::from_millis(200)),
"should have waited for refill: got {:?} expected >= {:?}",
total_elapsed,
expected_min
);
}
#[tokio::test]
async fn test_token_bucket_try_acquire() {
let tb = TokenBucket::new(1000, Some(2000));
assert!(tb.try_acquire(1000));
assert!(tb.try_acquire(1000));
assert!(!tb.try_acquire(1));
}
#[test]
fn token_bucket_reports_the_wait_for_a_token_deadline() {
let tb = TokenBucket::new(1000, Some(0));
assert_eq!(tb.time_until_acquire(0), Duration::ZERO);
let wait = tb.time_until_acquire(8);
assert!(
(Duration::from_millis(7)..=Duration::from_millis(8)).contains(&wait),
"8 bytes at 1000 bytes/sec should be ready in about 8 ms, got {wait:?}"
);
}
#[test]
fn test_token_bucket_available_tokens() {
let tb = TokenBucket::new(1000, Some(5000));
let initial = tb.available_tokens();
assert!(
(initial - 5000.0).abs() < 0.01,
"initial tokens should be ~5000, got {}",
initial
);
tb.try_acquire(2000);
let after = tb.available_tokens();
assert!(
(after - 3000.0).abs() < 0.01,
"after acquiring 2000, should have ~3000, got {}",
after
);
}
#[test]
fn test_rate_limiter_config_default() {
let cfg = RateLimiterConfig::default();
assert!(!cfg.is_limited());
assert!(cfg.download_rate().is_none());
assert!(cfg.upload_rate().is_none());
}
#[test]
fn test_rate_limiter_config_new() {
let cfg = RateLimiterConfig::new(Some(1024), Some(512));
assert!(cfg.is_limited());
assert_eq!(cfg.download_rate(), Some(1024));
assert_eq!(cfg.upload_rate(), Some(512));
}
#[test]
fn test_rate_limiter_config_download_only() {
let cfg = RateLimiterConfig::new(Some(2048), None);
assert!(cfg.is_limited());
assert_eq!(cfg.download_rate(), Some(2048));
assert!(cfg.upload_rate().is_none());
}
#[tokio::test]
async fn test_rate_limiter_unlimited() {
let rl = RateLimiter::unlimited();
assert!(!rl.is_download_limited());
assert!(!rl.is_upload_limited());
rl.acquire_download(999999).await;
rl.acquire_upload(999999).await;
}
#[tokio::test]
async fn test_rate_limiter_with_limits() {
let cfg = RateLimiterConfig::new(Some(5000), Some(1000)).with_burst(Some(1000), Some(500));
let rl = RateLimiter::new(&cfg);
assert!(rl.is_download_limited());
assert!(rl.is_upload_limited());
let start = Instant::now();
rl.acquire_download(6000).await;
let elapsed = start.elapsed();
assert!(
elapsed >= Duration::from_millis(800),
"should throttle: got {:?}",
elapsed
);
}
#[tokio::test]
async fn test_throttled_writer_no_limit_passthrough() {
use crate::filesystem::disk_writer::ByteArrayDiskWriter;
let raw = ByteArrayDiskWriter::new();
let rl = RateLimiter::unlimited();
let mut tw = ThrottledWriter::new(raw, rl);
tw.write(b"hello world").await.unwrap();
tw.write(b" foo bar baz").await.unwrap();
let result = tw.finalize().await.unwrap();
assert_eq!(result, b"hello world foo bar baz");
}
#[tokio::test]
async fn test_throttled_writer_with_limit() {
use crate::filesystem::disk_writer::ByteArrayDiskWriter;
let raw = ByteArrayDiskWriter::new();
let cfg = RateLimiterConfig::new(Some(100_000), None).with_burst(Some(1000), None);
let rl = RateLimiter::new(&cfg);
let mut tw = ThrottledWriter::new(raw, rl);
let data = vec![0xABu8; 50_000];
let start = Instant::now();
tw.write(&data).await.unwrap();
let elapsed = start.elapsed();
let result = tw.finalize().await.unwrap();
assert_eq!(result.len(), 50_000);
assert!(
elapsed >= Duration::from_millis(400),
"50KB at 100KB/s with 1KB burst should take >= 400ms, got {:?}",
elapsed
);
}
#[tokio::test]
async fn test_throttled_writer_chunk_size() {
use crate::filesystem::disk_writer::ByteArrayDiskWriter;
let raw = ByteArrayDiskWriter::new();
let cfg = RateLimiterConfig::new(Some(1_000_000), None);
let rl = RateLimiter::new(&cfg);
let mut tw = ThrottledWriter::new(raw, rl).with_chunk_size(1024);
let large_data = vec![0x42u8; 10_000];
tw.write(&large_data).await.unwrap();
let result = tw.finalize().await.unwrap();
assert_eq!(result.len(), 10_000);
}
#[cfg(test)]
struct TrackingSeekableWriter {
bytes_writes: usize,
slice_writes: usize,
data: Vec<u8>,
}
#[cfg(test)]
impl TrackingSeekableWriter {
fn new() -> Self {
Self {
bytes_writes: 0,
slice_writes: 0,
data: Vec::new(),
}
}
fn store(&mut self, offset: u64, data: &[u8]) -> crate::error::Result<()> {
let offset = usize::try_from(offset)
.map_err(|_| crate::error::Aria2Error::Io("offset exceeds usize range".into()))?;
let end = offset
.checked_add(data.len())
.ok_or_else(|| crate::error::Aria2Error::Io("write range overflow".into()))?;
if self.data.len() < end {
self.data.resize(end, 0);
}
self.data[offset..end].copy_from_slice(data);
Ok(())
}
}
#[cfg(test)]
#[async_trait::async_trait]
impl SeekableDiskWriter for TrackingSeekableWriter {
async fn open(&mut self) -> crate::error::Result<()> {
Ok(())
}
async fn write_at(&mut self, offset: u64, data: &[u8]) -> crate::error::Result<()> {
self.slice_writes += 1;
self.store(offset, data)
}
async fn write_bytes_at(
&mut self,
offset: u64,
data: bytes::Bytes,
) -> crate::error::Result<()> {
self.bytes_writes += 1;
self.store(offset, &data)
}
async fn read_at(&mut self, offset: u64, buf: &mut [u8]) -> crate::error::Result<usize> {
let offset = usize::try_from(offset)
.map_err(|_| crate::error::Aria2Error::Io("offset exceeds usize range".into()))?;
if offset >= self.data.len() {
return Ok(0);
}
let count = buf.len().min(self.data.len() - offset);
buf[..count].copy_from_slice(&self.data[offset..offset + count]);
Ok(count)
}
async fn truncate(&mut self, length: u64) -> crate::error::Result<()> {
let length = usize::try_from(length)
.map_err(|_| crate::error::Aria2Error::Io("length exceeds usize range".into()))?;
self.data.resize(length, 0);
Ok(())
}
async fn flush(&mut self) -> crate::error::Result<()> {
Ok(())
}
async fn sync_all(&mut self) -> crate::error::Result<()> {
Ok(())
}
async fn len(&self) -> crate::error::Result<u64> {
Ok(self.data.len() as u64)
}
fn path(&self) -> &std::path::Path {
std::path::Path::new("tracking")
}
}
#[tokio::test]
async fn test_throttled_seekable_bytes_preserves_bytes_path() {
let cfg = RateLimiterConfig::new(Some(1_000_000), None).with_burst(Some(1_000_000), None);
let rl = RateLimiter::new(&cfg);
let chunk_size = crate::constants::RATE_LIMITER_MIN_CHUNK_SIZE;
let payload = bytes::Bytes::from(vec![0x5A; chunk_size * 2 + 1]);
let mut writer =
ThrottledWriter::new(TrackingSeekableWriter::new(), rl).with_chunk_size(chunk_size);
writer.write_bytes_at(3, payload.clone()).await.unwrap();
let writer = writer.into_inner();
assert_eq!(writer.bytes_writes, 3);
assert_eq!(writer.slice_writes, 0);
assert_eq!(&writer.data[3..3 + payload.len()], payload.as_ref());
}
#[tokio::test]
async fn test_rate_limiter_zero_rate_means_unlimited() {
let cfg = RateLimiterConfig::new(Some(0), Some(0));
let rl = RateLimiter::new(&cfg);
assert!(!rl.is_download_limited());
assert!(!rl.is_upload_limited());
}
#[tokio::test]
async fn test_token_bucket_concurrent_no_deadlock() {
let bucket = Arc::new(TokenBucket::new(10_000_000, Some(10_000_000)));
let mut handles = Vec::with_capacity(4);
for task_id in 0..4u8 {
let b = bucket.clone();
handles.push(tokio::spawn(async move {
for _ in 0..1000 {
b.acquire(1000).await;
}
task_id }));
}
for (i, h) in handles.into_iter().enumerate() {
let id = h.await.expect("task should complete without panic");
assert_eq!(id as usize, i, "task ordering preserved");
}
let remaining = bucket.available_tokens();
assert!(
remaining > 5_000_000.0,
"should have ~6MB left after consuming 4MB, got {}",
remaining
);
}
#[tokio::test]
async fn test_throttled_writer_batches_token_acquisition() {
use crate::filesystem::disk_writer::ByteArrayDiskWriter;
let raw = ByteArrayDiskWriter::new();
let cfg = RateLimiterConfig::new(Some(10_000), None).with_burst(Some(0), None);
let rl = RateLimiter::new(&cfg);
let mut tw = ThrottledWriter::new(raw, rl).with_chunk_size(100);
let data = vec![0x77u8; 5_000];
let start = Instant::now();
tw.write(&data).await.unwrap();
let elapsed = start.elapsed();
let result = tw.finalize().await.unwrap();
assert_eq!(result.len(), 5_000, "data integrity preserved");
assert!(
result.iter().all(|&b| b == 0x77),
"all bytes should be 0x77"
);
assert!(
elapsed >= Duration::from_millis(300),
"batch acquire should wait >= 300ms at 10KB/s rate, got {:?}",
elapsed
);
assert!(
elapsed < Duration::from_secs(2),
"batch acquire should complete well under 2s, got {:?}",
elapsed
);
}
#[tokio::test]
async fn test_rate_limiter_clone_shares_state() {
let cfg = RateLimiterConfig::new(Some(10000), None).with_burst(Some(5000), None);
let rl1 = RateLimiter::new(&cfg);
let rl2 = rl1.clone();
assert!(rl1.is_download_limited());
assert!(rl2.is_download_limited());
rl1.acquire_download(3000).await;
rl2.acquire_download(3000).await;
let config = rl1.config().await;
assert!(config.download_rate().is_some());
}
#[tokio::test]
async fn test_rate_limiter_high_rate_low_latency() {
let cfg = RateLimiterConfig::new(Some(100_000_000), None).with_burst(Some(1_000_000), None);
let rl = RateLimiter::new(&cfg);
let start = Instant::now();
rl.acquire_download(100_000).await;
let elapsed = start.elapsed();
assert!(
elapsed < Duration::from_millis(50),
"100MB/s rate with 1MB burst should be near-instant for 100KB: got {:?}",
elapsed
);
}
#[tokio::test]
async fn test_token_bucket_set_rate() {
let tb = TokenBucket::new(1_000_000, Some(1000)); assert!(tb.try_acquire(1000));
tb.set_rate(10_000_000);
let rate = tb.rate();
assert!(
(rate - 10_000_000.0).abs() < 1.0,
"rate should be ~10 MB/s, got {}",
rate
);
}
#[tokio::test]
async fn test_token_bucket_set_rate_to_zero() {
let tb = TokenBucket::new(1_000_000, Some(1000));
tb.set_rate(0);
let rate = tb.rate();
assert!(
(rate - 0.0).abs() < 0.01,
"rate should be 0 after set_rate(0), got {}",
rate
);
}
#[tokio::test]
async fn test_token_bucket_set_unlimited() {
let tb = TokenBucket::new(1_000, None); assert!(!tb.is_unlimited());
tb.set_unlimited(true);
assert!(tb.is_unlimited());
let start = Instant::now();
tb.acquire(1_000_000_000).await;
let elapsed = start.elapsed();
assert!(
elapsed < Duration::from_millis(50),
"unlimited acquire should be instant, got {:?}",
elapsed
);
}
#[tokio::test]
async fn test_rate_limiter_set_download_rate() {
let rl = RateLimiter::new(&RateLimiterConfig::new(Some(1_000_000), None)); assert!(rl.is_download_limited());
rl.set_download_rate(Some(5_000_000));
assert!(rl.is_download_limited());
let config = rl.config().await;
assert_eq!(config.download_rate(), Some(5_000_000));
rl.set_download_rate(None);
assert!(!rl.is_download_limited());
let config = rl.config().await;
assert!(
config.download_rate().is_none(),
"download_rate should be None after set_download_rate(None), got {:?}",
config.download_rate()
);
}
#[tokio::test]
async fn test_rate_limiter_set_upload_rate() {
let rl = RateLimiter::new(&RateLimiterConfig::new(None, Some(500_000))); assert!(rl.is_upload_limited());
rl.set_upload_rate(Some(2_000_000)); assert!(rl.is_upload_limited());
let config = rl.config().await;
assert_eq!(config.upload_rate(), Some(2_000_000));
rl.set_upload_rate(Some(0));
assert!(!rl.is_upload_limited());
let config = rl.config().await;
assert!(config.upload_rate().is_none());
}
#[tokio::test]
async fn test_setting_upload_limit_from_unlimited_starts_with_only_the_default_burst() {
let limiter = RateLimiter::unlimited();
limiter.set_upload_rate(Some(1));
let burst_bytes = crate::constants::DEFAULT_BURST_BYTES as u64;
assert!(limiter.try_acquire_upload(burst_bytes).await);
assert!(
!limiter.try_acquire_upload(1).await,
"switching from unlimited to limited must not preserve an effectively infinite token balance"
);
}
#[tokio::test]
async fn test_unlimited_rate_limiter_preserves_configured_burst_for_later_limits() {
let limiter =
RateLimiter::new(&RateLimiterConfig::new(None, None).with_burst(Some(3), Some(5)));
limiter.set_download_rate(Some(1));
limiter.set_upload_rate(Some(1));
assert!(limiter.try_acquire_download(3).await);
assert!(!limiter.try_acquire_download(1).await);
assert!(limiter.try_acquire_upload(5).await);
assert!(!limiter.try_acquire_upload(1).await);
}
#[tokio::test]
async fn test_token_bucket_unlimited_wakes_waiting_acquire() {
let bucket = Arc::new(TokenBucket::new(100, Some(0)));
let waiting_bucket = Arc::clone(&bucket);
let acquire = tokio::spawn(async move {
waiting_bucket.acquire(100).await;
});
tokio::time::sleep(Duration::from_millis(20)).await;
bucket.set_unlimited(true);
tokio::time::timeout(Duration::from_millis(300), acquire)
.await
.expect("changing the rate should wake a blocked acquire")
.expect("acquire task should not panic");
}
#[tokio::test]
async fn test_rate_limiter_clone_shares_inner_state() {
let rl = RateLimiter::new(&RateLimiterConfig::new(Some(1_000_000), None));
let rl_clone = rl.clone();
rl.set_download_rate(Some(5_000_000));
let config = rl_clone.config().await;
assert_eq!(
config.download_rate(),
Some(5_000_000),
"clone should see updated rate via shared Arc<inner>"
);
assert!(
rl_clone.is_download_limited(),
"clone should see updated limited flag via shared Arc<inner>"
);
rl_clone.set_download_rate(None);
assert!(
!rl.is_download_limited(),
"original should see unlimited flag set by clone"
);
}