use std::collections::VecDeque;
use std::time::Duration;
use tokio::sync::Mutex;
use tokio::time::Instant;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Plan {
Free,
Light,
Standard,
Premium,
}
impl Plan {
pub fn requests_per_minute(self) -> u32 {
match self {
Plan::Free => 5,
Plan::Light => 60,
Plan::Standard => 120,
Plan::Premium => 500,
}
}
}
#[derive(Debug)]
pub(crate) struct RateLimiter {
max_per_window: u32,
window: Duration,
history: Mutex<VecDeque<Instant>>,
}
impl RateLimiter {
pub(crate) fn per_minute(max: u32) -> Self {
Self {
max_per_window: max,
window: Duration::from_secs(60),
history: Mutex::new(VecDeque::new()),
}
}
pub(crate) async fn acquire(&self) {
loop {
let wait = {
let mut history = self.history.lock().await;
let now = Instant::now();
while let Some(&oldest) = history.front() {
if now.duration_since(oldest) >= self.window {
history.pop_front();
} else {
break;
}
}
if (history.len() as u32) < self.max_per_window {
history.push_back(now);
None
} else {
let oldest = *history.front().expect("history is non-empty here");
Some((oldest + self.window).saturating_duration_since(now))
}
};
match wait {
None => return,
Some(duration) => tokio::time::sleep(duration).await,
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn plan_rates_match_official_pricing() {
assert_eq!(Plan::Free.requests_per_minute(), 5);
assert_eq!(Plan::Light.requests_per_minute(), 60);
assert_eq!(Plan::Standard.requests_per_minute(), 120);
assert_eq!(Plan::Premium.requests_per_minute(), 500);
}
#[tokio::test(start_paused = true)]
async fn acquire_is_instant_under_the_limit() {
let limiter = RateLimiter::per_minute(2);
let start = Instant::now();
limiter.acquire().await;
limiter.acquire().await;
assert!(start.elapsed() < Duration::from_secs(1));
}
#[tokio::test(start_paused = true)]
async fn acquire_waits_when_window_is_full() {
let limiter = RateLimiter::per_minute(2);
let start = Instant::now();
limiter.acquire().await;
limiter.acquire().await;
limiter.acquire().await;
assert!(start.elapsed() >= Duration::from_secs(60));
}
#[tokio::test(start_paused = true)]
async fn window_slides_after_time_passes() {
let limiter = RateLimiter::per_minute(2);
limiter.acquire().await;
limiter.acquire().await;
tokio::time::sleep(Duration::from_secs(61)).await;
let start = Instant::now();
limiter.acquire().await;
assert!(start.elapsed() < Duration::from_secs(1));
}
}