async-bulkhead 0.1.0

An async semaphore-based bulkhead implementation
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

extern crate tokio;

use super::*;
use assert_matches::assert_matches;

async fn two_calls_test_helper(bulkhead: Bulkhead) -> Result<(), BulkheadError> {
    let bulkhead_clone = bulkhead.clone();
    let handle = tokio::spawn(async move {
        let sleep_fut = tokio::time::sleep(Duration::from_millis(50));
        bulkhead_clone.limit(sleep_fut).await
    });
    let result_fut = async {
        tokio::time::sleep(Duration::from_millis(20)).await;
        bulkhead.limit(async {}).await
    };
    let (result, _) = tokio::join!(result_fut, handle);
    result
}

#[tokio::test]
pub async fn times_out() {
    let bulkhead = Bulkhead::builder().max_concurrent_calls(1).build().unwrap();
    let result = two_calls_test_helper(bulkhead).await;
    assert_matches!(result, Err(BulkheadError::Timeout));
}

#[tokio::test]
pub async fn doesnt_time_out() {
    let bulkhead = Bulkhead::default();
    let result = bulkhead.limit(async {}).await;
    assert_matches!(result, Ok(_));
}

#[tokio::test]
pub async fn doesnt_time_out_long() {
    let bulkhead = Bulkhead::builder()
        .max_concurrent_calls(1)
        .max_wait_duration(Duration::from_secs(2))
        .build()
        .unwrap();
    let result = two_calls_test_helper(bulkhead).await;
    assert_matches!(result, Ok(_));
}

#[test]
pub fn invalid_max_concurrent_calls() {
    let result = Bulkhead::builder().max_concurrent_calls(0).build();
    assert_matches!(result, Err(BulkheadError::InvalidConcurrentCalls));
}