camber 0.1.6

Opinionated async Rust for IO-bound services on top of Tokio
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

mod common;

use camber::http::{self, Request, Response, Router};
use camber::{RuntimeError, runtime};
use std::sync::Arc;
use std::sync::atomic::{AtomicU32, Ordering};
use std::time::Duration;

#[camber::test]
async fn client_retries_on_transient_error() {
    let count = Arc::new(AtomicU32::new(0));
    let c = Arc::clone(&count);
    let mut backend = Router::new();
    backend.get("/retry", move |_req: &Request| {
        let n = c.fetch_add(1, Ordering::Relaxed);
        async move {
            match n < 2 {
                true => Response::empty(503),
                false => Response::text(200, "ok"),
            }
        }
    });
    let addr = common::spawn_server(backend);

    let resp = http::client()
        .retries(3)
        .backoff(Duration::from_millis(10))
        .get(&format!("http://{addr}/retry"))
        .await
        .unwrap();

    assert_eq!(resp.status(), 200);
    assert_eq!(resp.body(), "ok");
    assert_eq!(count.load(Ordering::Relaxed), 3);

    runtime::request_shutdown();
}

#[camber::test]
async fn client_does_not_retry_on_4xx() {
    let count = Arc::new(AtomicU32::new(0));
    let c = Arc::clone(&count);
    let mut backend = Router::new();
    backend.get("/bad", move |_req: &Request| {
        c.fetch_add(1, Ordering::Relaxed);
        async { Response::text(400, "bad request") }
    });
    let addr = common::spawn_server(backend);

    let resp = http::client()
        .retries(3)
        .backoff(Duration::from_millis(10))
        .get(&format!("http://{addr}/bad"))
        .await
        .unwrap();

    assert_eq!(resp.status(), 400);
    assert_eq!(count.load(Ordering::Relaxed), 1);

    runtime::request_shutdown();
}

#[camber::test]
async fn client_exhausts_retries_and_returns_last_error() {
    let count = Arc::new(AtomicU32::new(0));
    let c = Arc::clone(&count);
    let mut backend = Router::new();
    backend.get("/fail", move |_req: &Request| {
        c.fetch_add(1, Ordering::Relaxed);
        async { Response::empty(503) }
    });
    let addr = common::spawn_server(backend);

    let resp = http::client()
        .retries(2)
        .backoff(Duration::from_millis(10))
        .get(&format!("http://{addr}/fail"))
        .await
        .unwrap();

    assert_eq!(resp.status(), 503);
    assert_eq!(count.load(Ordering::Relaxed), 3);

    runtime::request_shutdown();
}

#[camber::test]
async fn client_free_functions_do_not_retry() {
    let count = Arc::new(AtomicU32::new(0));
    let c = Arc::clone(&count);
    let mut backend = Router::new();
    backend.get("/once", move |_req: &Request| {
        c.fetch_add(1, Ordering::Relaxed);
        async { Response::empty(503) }
    });
    let addr = common::spawn_server(backend);

    let resp = http::get(&format!("http://{addr}/once")).await.unwrap();

    assert_eq!(resp.status(), 503);
    assert_eq!(count.load(Ordering::Relaxed), 1);

    runtime::request_shutdown();
}

#[camber::test]
async fn client_retries_on_timeout() {
    let count = Arc::new(AtomicU32::new(0));
    let c = Arc::clone(&count);
    let mut backend = Router::new();
    backend.get("/slow", move |_req: &Request| {
        c.fetch_add(1, Ordering::Relaxed);
        async {
            std::thread::sleep(Duration::from_millis(200));
            Response::text(200, "slow")
        }
    });
    let addr = common::spawn_server(backend);

    let result = http::client()
        .retries(1)
        .backoff(Duration::from_millis(10))
        .read_timeout(Duration::from_millis(50))
        .get(&format!("http://{addr}/slow"))
        .await;

    match &result {
        Err(RuntimeError::Timeout) => {}
        Err(e) => panic!("expected Timeout, got error: {e}"),
        Ok(resp) => panic!("expected Timeout, got status {}", resp.status()),
    }

    assert_eq!(count.load(Ordering::Relaxed), 2);

    runtime::request_shutdown();
}