1 #![cfg(all(feature = "buffer", feature = "limit", feature = "retry"))]
2 mod support;
3 use futures_util::{future::Ready, pin_mut};
4 use std::time::Duration;
5 use tower::builder::ServiceBuilder;
6 use tower::retry::Policy;
7 use tower::util::ServiceExt;
8 use tower_service::*;
9 use tower_test::{assert_request_eq, mock};
10 
11 #[tokio::test(flavor = "current_thread")]
builder_service()12 async fn builder_service() {
13     let _t = support::trace_init();
14 
15     let (service, handle) = mock::pair();
16     pin_mut!(handle);
17 
18     let policy = MockPolicy::<&'static str, bool>::default();
19     let mut client = ServiceBuilder::new()
20         .buffer(5)
21         .concurrency_limit(5)
22         .rate_limit(5, Duration::from_secs(5))
23         .retry(policy)
24         .map_response(|r: &'static str| r == "world")
25         .map_request(|r: &'static str| r == "hello")
26         .service(service);
27 
28     // allow a request through
29     handle.allow(1);
30 
31     let fut = client.ready().await.unwrap().call("hello");
32     assert_request_eq!(handle, true).send_response("world");
33     assert!(fut.await.unwrap());
34 }
35 
36 #[derive(Debug, Clone, Default)]
37 struct MockPolicy<Req, Res> {
38     _pd: std::marker::PhantomData<(Req, Res)>,
39 }
40 
41 impl<Req, Res, E> Policy<Req, Res, E> for MockPolicy<Req, Res>
42 where
43     Req: Clone,
44     E: Into<Box<dyn std::error::Error + Send + Sync + 'static>>,
45 {
46     type Future = Ready<Self>;
47 
retry(&self, _req: &Req, _result: Result<&Res, &E>) -> Option<Self::Future>48     fn retry(&self, _req: &Req, _result: Result<&Res, &E>) -> Option<Self::Future> {
49         None
50     }
51 
clone_request(&self, req: &Req) -> Option<Req>52     fn clone_request(&self, req: &Req) -> Option<Req> {
53         Some(req.clone())
54     }
55 }
56