trypema 2.0.0

High-performance rate limiting primitives in Rust, designed for concurrency safety, low overhead, and predictable latency.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

//! Shared test helpers for Redis-backed rate limiter tests.

use std::{env, time::Duration};

use crate::{
    common::RateType,
    redis::{RedisKey, common::RedisKeyGenerator},
};

use super::runtime;

/// Read `REDIS_URL` from the environment, panic if unset.
pub fn redis_url() -> String {
    env::var("REDIS_URL").unwrap_or_else(|_| {
        panic!(
            "REDIS_URL env var must be set for Redis-backed tests \
             (e.g. REDIS_URL=redis://127.0.0.1:16379/)"
        )
    })
}

/// Create a Redis connection manager for provider tests.
pub async fn connection_manager() -> redis::aio::ConnectionManager {
    redis::Client::open(redis_url())
        .unwrap()
        .get_connection_manager()
        .await
        .unwrap()
}

/// Generate a unique, random test prefix so parallel tests don't collide.
pub fn unique_prefix() -> RedisKey {
    let n: u64 = rand::random();
    RedisKey::try_from(format!("trypema_test_{n}")).unwrap()
}

/// Convenience constructor for a `RedisKey` from a string literal.
pub fn key(s: &str) -> RedisKey {
    RedisKey::try_from(s.to_string()).unwrap()
}

/// Return a `RedisKeyGenerator` for the given prefix and rate type.
pub fn key_gen(prefix: &RedisKey, rate_type: RateType) -> RedisKeyGenerator {
    RedisKeyGenerator::new(prefix.clone(), rate_type)
}

/// Wait long enough for the background hybrid committer to flush two ticks.
pub async fn wait_for_hybrid_sync(sync_interval: u64) {
    runtime::async_sleep(Duration::from_millis(sync_interval * 2 + 50)).await;
}