1 use futures::{
2 future::{self, FutureResult},
3 prelude::*,
4 };
5 use std::time::Duration;
6 use tower::builder::ServiceBuilder;
7 use tower_buffer::BufferLayer;
8 use tower_limit::{concurrency::ConcurrencyLimitLayer, rate::RateLimitLayer};
9 use tower_retry::{Policy, RetryLayer};
10 use tower_service::*;
11 use void::Void;
12
13 #[test]
builder_service()14 fn builder_service() {
15 tokio::run(future::lazy(|| {
16 let policy = MockPolicy;
17 let mut client = ServiceBuilder::new()
18 .layer(BufferLayer::new(5))
19 .layer(ConcurrencyLimitLayer::new(5))
20 .layer(RateLimitLayer::new(5, Duration::from_secs(1)))
21 .layer(RetryLayer::new(policy))
22 .layer(BufferLayer::new(5))
23 .service(MockSvc);
24
25 client.poll_ready().unwrap();
26 client
27 .call(Request)
28 .map(|_| ())
29 .map_err(|_| panic!("this is bad"))
30 }));
31 }
32
33 #[derive(Debug, Clone)]
34 struct Request;
35 #[derive(Debug, Clone)]
36 struct Response;
37 #[derive(Debug)]
38 struct MockSvc;
39 impl Service<Request> for MockSvc {
40 type Response = Response;
41 type Error = Void;
42 type Future = FutureResult<Self::Response, Self::Error>;
43
poll_ready(&mut self) -> Poll<(), Self::Error>44 fn poll_ready(&mut self) -> Poll<(), Self::Error> {
45 Ok(().into())
46 }
47
call(&mut self, _: Request) -> Self::Future48 fn call(&mut self, _: Request) -> Self::Future {
49 future::ok(Response)
50 }
51 }
52
53 #[derive(Debug, Clone)]
54 struct MockPolicy;
55
56 impl<E> Policy<Request, Response, E> for MockPolicy
57 where
58 E: Into<Box<dyn std::error::Error + Send + Sync + 'static>>,
59 {
60 type Future = FutureResult<Self, ()>;
61
retry(&self, _req: &Request, _result: Result<&Response, &E>) -> Option<Self::Future>62 fn retry(&self, _req: &Request, _result: Result<&Response, &E>) -> Option<Self::Future> {
63 None
64 }
65
clone_request(&self, req: &Request) -> Option<Request>66 fn clone_request(&self, req: &Request) -> Option<Request> {
67 Some(req.clone())
68 }
69 }
70