governor 0.10.4

A rate-limiting implementation in Rust
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

#![cfg(feature = "std")]

use assertables::*;
use futures_executor::block_on;
use futures_util::sink::SinkExt;
use governor::{prelude::*, Quota, RateLimiter};
use nonzero_ext::*;
use std::sync::Arc;
use std::time::{Duration, Instant};

#[cfg(feature = "jitter")]
use governor::Jitter;

#[test]
#[allow(clippy::unit_cmp)]
fn sink() {
    let lim = Arc::new(RateLimiter::direct(Quota::per_second(nonzero!(10u32))));
    let mut sink = Vec::new().ratelimit_sink(&lim);
    let i = Instant::now();

    for _ in 0..10 {
        block_on(sink.send(())).unwrap();
    }
    assert_lt!(i.elapsed(), Duration::from_millis(100));

    block_on(sink.send(())).unwrap();
    assert_in_range!(i.elapsed().as_millis(), 100..201);

    block_on(sink.send(())).unwrap();
    assert_in_range!(i.elapsed().as_millis(), 200..301);

    let result = sink.get_ref();
    assert_eq!(result.len(), 12);
    assert!(result.iter().all(|&elt| elt == ()));
}

#[test]
fn auxilliary_sink_methods() {
    let lim = Arc::new(RateLimiter::direct(Quota::per_second(nonzero!(10u32))));
    // TODO: use futures_ringbuf to build a Sink-that-is-a-Stream and
    // use it as both
    // (https://github.com/najamelan/futures_ringbuf/issues/5)
    let mut sink = Vec::<u8>::new().ratelimit_sink(&lim);

    // Closes the underlying sink:
    assert!(block_on(sink.close()).is_ok());
}

#[cfg(all(feature = "jitter", test))]
#[cfg_attr(feature = "jitter", test)]
#[allow(clippy::unit_cmp)]
fn sink_with_jitter() {
    let lim = Arc::new(RateLimiter::direct(Quota::per_second(nonzero!(10u32))));
    let mut sink =
        Vec::new().ratelimit_sink_with_jitter(&lim, Jitter::up_to(Duration::from_nanos(1)));
    let i = Instant::now();

    for _ in 0..10 {
        block_on(sink.send(())).unwrap();
    }
    assert_le!(i.elapsed(), Duration::from_millis(100),);

    block_on(sink.send(())).unwrap();
    assert_in_range!(i.elapsed().as_millis(), 100..201);

    block_on(sink.send(())).unwrap();
    assert_in_range!(i.elapsed().as_millis(), 200..301);

    let result = sink.into_inner();
    assert_eq!(result.len(), 12);
    assert!(result.into_iter().all(|elt| elt == ()));
}