rate_limiters 0.1.13

Flexible and easy-to-use Rust library for implementing rate limits.
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

#[cfg(test)]
mod sequential_tests {
    use crate::sliding_window_counter::{SlidingWindowCounter, SlidingWindowCounterConfig};
    use crate::token_bucket::r#impl::RateLimiter;
    use std::thread;
    use std::time::Duration;

    #[test]
    fn basic_test() {
        let now_unix = || {
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_secs()
        };

        let mut bucket = SlidingWindowCounter::new(SlidingWindowCounterConfig {
            capacity: 10,
            window_secs: 2,
        });
        assert_eq!(bucket.get_limit(), 10);
        assert_eq!(bucket.get_remaining(), 10);
        assert_eq!(bucket.get_used(), 0);
        assert!(bucket.get_reset() >= now_unix());

        assert!(bucket.try_acquire(5));
        assert_eq!(bucket.get_limit(), 10);
        assert_eq!(bucket.get_remaining(), 5);
        assert_eq!(bucket.get_used(), 5);
        let diff = bucket.get_reset() - now_unix();
        assert!(diff <= 2 && diff >= 1);

        assert!(bucket.try_acquire(5));
        assert_eq!(bucket.get_limit(), 10);
        assert_eq!(bucket.get_remaining(), 0);
        assert_eq!(bucket.get_used(), 10);
        let diff = bucket.get_reset() - now_unix();
        assert!(diff <= 2 && diff >= 1);

        assert!(!bucket.try_acquire(1));
        assert_eq!(bucket.get_limit(), 10);
        assert_eq!(bucket.get_remaining(), 0);
        assert_eq!(bucket.get_used(), 10);
        let diff = bucket.get_reset() - now_unix();
        assert!(diff <= 2 && diff >= 1);

        thread::sleep(Duration::from_secs(1));
        bucket.refresh(); // <-- Call refresh to update details w/ try_acquire call
        assert_eq!(bucket.get_limit(), 10);
        assert_eq!(bucket.get_remaining(), 0);
        assert_eq!(bucket.get_used(), 10);
        let diff = bucket.get_reset() - now_unix();
        assert!(diff <= 2 && diff >= 1);

        thread::sleep(Duration::from_secs(1));
        bucket.refresh(); // <-- Call refresh to update details w/ try_acquire call
        assert_eq!(bucket.get_limit(), 10);
        assert_eq!(bucket.get_remaining(), 10);
        assert_eq!(bucket.get_used(), 0);
        assert!(bucket.get_reset() >= now_unix());
    }

    #[test]
    fn get_reset_anchored_on_last_tick_not_now() {
        // Regression: get_reset() used `now_unix() + (idx + 1)`, which is wrong
        // when refresh() hasn't been called recently — it ignored the time
        // already elapsed since the last tick. It now anchors on `last_tick`.
        let now_unix = || {
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_secs()
        };

        let mut bucket = SlidingWindowCounter::new(SlidingWindowCounterConfig {
            capacity: 10,
            window_secs: 3,
        });
        assert!(bucket.try_acquire(5));
        let initial_reset = bucket.get_reset();
        let initial_now = now_unix();
        // Slot is in the back; expires after 3 seconds.
        assert!(initial_reset - initial_now <= 3);
        assert!(initial_reset - initial_now >= 2);

        // Without calling refresh, after 1s the absolute reset timestamp must
        // not move forward (slot expiry is anchored on last_tick, not now).
        thread::sleep(Duration::from_secs(1));
        let later_reset = bucket.get_reset();
        assert!(
            later_reset <= initial_reset,
            "get_reset drifted forward: initial={}, later={}",
            initial_reset,
            later_reset
        );
    }
}