From ab22dcea685c8400d2bac57bab426a548d5afed2 Mon Sep 17 00:00:00 2001 From: Nikolay Kim Date: Thu, 14 Nov 2019 18:17:10 +0600 Subject: [PATCH] restore service tests --- actix-connect/src/ssl/openssl.rs | 7 +- actix-service/src/and_then.rs | 134 +++++++++++++++---------------- actix-service/src/apply.rs | 99 ++++++++++++----------- actix-service/src/map.rs | 49 ++++++----- actix-service/src/map_err.rs | 81 +++++++++---------- actix-service/src/then.rs | 18 ++--- 6 files changed, 189 insertions(+), 199 deletions(-) diff --git a/actix-connect/src/ssl/openssl.rs b/actix-connect/src/ssl/openssl.rs index 491bcc1d..9f46808c 100644 --- a/actix-connect/src/ssl/openssl.rs +++ b/actix-connect/src/ssl/openssl.rs @@ -8,7 +8,6 @@ use actix_codec::{AsyncRead, AsyncWrite}; use actix_service::{Service, ServiceFactory}; use futures::future::{err, ok, Either, FutureExt, LocalBoxFuture, Ready}; use open_ssl::ssl::SslConnector; -use pin_project::pin_project; use tokio_net::tcp::TcpStream; use tokio_openssl::{HandshakeError, SslStream}; use trust_dns_resolver::AsyncResolver; @@ -124,9 +123,7 @@ where } } -#[pin_project] pub struct ConnectAsyncExt { - #[pin] fut: LocalBoxFuture<'static, Result, HandshakeError>>, stream: Option>, _t: PhantomData, @@ -139,9 +136,9 @@ where type Output = Result>, io::Error>; fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll { - let this = self.project(); + let this = self.get_mut(); - match this.fut.poll(cx) { + match Pin::new(&mut this.fut).poll(cx) { Poll::Ready(Ok(stream)) => { let s = this.stream.take().unwrap(); trace!("SSL Handshake success: {:?}", s.host()); diff --git a/actix-service/src/and_then.rs b/actix-service/src/and_then.rs index ee6d7370..091fd141 100644 --- a/actix-service/src/and_then.rs +++ b/actix-service/src/and_then.rs @@ -251,86 +251,80 @@ where #[cfg(test)] mod tests { - // use futures::future::{ok, poll_fn, ready, Ready}; - // use futures::Poll; - // use std::cell::Cell; - // use std::rc::Rc; + use std::cell::Cell; + use std::rc::Rc; + use std::task::{Context, Poll}; - // use super::*; - // use crate::{NewService, Service, ServiceExt}; + use futures::future::{lazy, ok, ready, Ready}; - // struct Srv1(Rc>); + use crate::{factory_fn, pipeline, pipeline_factory, Service, ServiceFactory}; - // impl Service for Srv1 { - // type Request = &'static str; - // type Response = &'static str; - // type Error = (); - // type Future = Ready>; + struct Srv1(Rc>); - // fn poll_ready( - // self: Pin<&mut Self>, - // cx: &mut Context<'_>, - // ) -> Poll> { - // self.0.set(self.0.get() + 1); - // Poll::Ready(Ok(())) - // } + impl Service for Srv1 { + type Request = &'static str; + type Response = &'static str; + type Error = (); + type Future = Ready>; - // fn call(&mut self, req: &'static str) -> Self::Future { - // ok(req) - // } - // } + fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { + self.0.set(self.0.get() + 1); + Poll::Ready(Ok(())) + } - // #[derive(Clone)] - // struct Srv2(Rc>); + fn call(&mut self, req: &'static str) -> Self::Future { + ok(req) + } + } - // impl Service for Srv2 { - // type Request = &'static str; - // type Response = (&'static str, &'static str); - // type Error = (); - // type Future = Ready>; + #[derive(Clone)] + struct Srv2(Rc>); - // fn poll_ready( - // self: Pin<&mut Self>, - // cx: &mut Context<'_>, - // ) -> Poll> { - // self.0.set(self.0.get() + 1); - // Poll::Ready(Ok(())) - // } + impl Service for Srv2 { + type Request = &'static str; + type Response = (&'static str, &'static str); + type Error = (); + type Future = Ready>; - // fn call(&mut self, req: &'static str) -> Self::Future { - // ok((req, "srv2")) - // } - // } + fn poll_ready(&mut self, _: &mut Context) -> Poll> { + self.0.set(self.0.get() + 1); + Poll::Ready(Ok(())) + } - // #[tokio::test] - // async fn test_poll_ready() { - // let cnt = Rc::new(Cell::new(0)); - // let mut srv = Srv1(cnt.clone()).and_then(Srv2(cnt.clone())); - // let res = srv.poll_once().await; - // assert_eq!(res, Poll::Ready(Ok(()))); - // assert_eq!(cnt.get(), 2); - // } + fn call(&mut self, req: &'static str) -> Self::Future { + ok((req, "srv2")) + } + } - // #[tokio::test] - // async fn test_call() { - // let cnt = Rc::new(Cell::new(0)); - // let mut srv = Srv1(cnt.clone()).and_then(Srv2(cnt)); - // let res = srv.call("srv1").await; - // assert!(res.is_ok()); - // assert_eq!(res.unwrap(), (("srv1", "srv2"))); - // } + #[tokio::test] + async fn test_poll_ready() { + let cnt = Rc::new(Cell::new(0)); + let mut srv = pipeline(Srv1(cnt.clone())).and_then(Srv2(cnt.clone())); + let res = lazy(|cx| srv.poll_ready(cx)).await; + assert_eq!(res, Poll::Ready(Ok(()))); + assert_eq!(cnt.get(), 2); + } - // #[tokio::test] - // async fn test_new_service() { - // let cnt = Rc::new(Cell::new(0)); - // let cnt2 = cnt.clone(); - // let blank = move || ready(Ok::<_, ()>(Srv1(cnt2.clone()))); - // let new_srv = blank - // .into_new_service() - // .and_then(move || ready(Ok(Srv2(cnt.clone())))); - // let mut srv = new_srv.new_service(&()).await.unwrap(); - // let res = srv.call("srv1").await; - // assert!(res.is_ok()); - // assert_eq!(res.unwrap(), ("srv1", "srv2")); - // } + #[tokio::test] + async fn test_call() { + let cnt = Rc::new(Cell::new(0)); + let mut srv = pipeline(Srv1(cnt.clone())).and_then(Srv2(cnt)); + let res = srv.call("srv1").await; + assert!(res.is_ok()); + assert_eq!(res.unwrap(), (("srv1", "srv2"))); + } + + #[tokio::test] + async fn test_new_service() { + let cnt = Rc::new(Cell::new(0)); + let cnt2 = cnt.clone(); + let new_srv = + pipeline_factory(factory_fn(move || ready(Ok::<_, ()>(Srv1(cnt2.clone()))))) + .and_then(move || ready(Ok(Srv2(cnt.clone())))); + + let mut srv = new_srv.new_service(&()).await.unwrap(); + let res = srv.call("srv1").await; + assert!(res.is_ok()); + assert_eq!(res.unwrap(), ("srv1", "srv2")); + } } diff --git a/actix-service/src/apply.rs b/actix-service/src/apply.rs index fd2dab83..e4a42f4d 100644 --- a/actix-service/src/apply.rs +++ b/actix-service/src/apply.rs @@ -183,60 +183,67 @@ where #[cfg(test)] mod tests { - // use futures::future::{ok, Ready}; - // use futures::{Future, Poll, TryFutureExt}; + use std::task::{Context, Poll}; - // use super::*; - // use crate::{IntoService, NewService, Service, ServiceExt}; + use futures::future::{lazy, ok, Ready}; - // #[derive(Clone)] - // struct Srv; + use super::*; + use crate::{pipeline, pipeline_factory, Service, ServiceFactory}; - // impl Service for Srv { - // type Request = (); - // type Response = (); - // type Error = (); - // type Future = Ready>; + #[derive(Clone)] + struct Srv; - // fn poll_ready( - // self: Pin<&mut Self>, - // ctx: &mut Context<'_>, - // ) -> Poll> { - // Poll::Ready(Ok(())) - // } + impl Service for Srv { + type Request = (); + type Response = (); + type Error = (); + type Future = Ready>; - // fn call(&mut self, _: ()) -> Self::Future { - // ok(()) - // } - // } + fn poll_ready(&mut self, _: &mut Context) -> Poll> { + Poll::Ready(Ok(())) + } - // #[tokio::test] - // async fn test_call() { - // let blank = |req| ok(req); + fn call(&mut self, _: ()) -> Self::Future { + ok(()) + } + } - // let mut srv = blank - // .into_service() - // .apply_fn(Srv, |req: &'static str, srv| { - // srv.call(()).map_ok(move |res| (req, res)) - // }); - // assert_eq!(srv.poll_once().await, Poll::Ready(Ok(()))); - // let res = srv.call("srv").await; - // assert!(res.is_ok()); - // assert_eq!(res.unwrap(), (("srv", ()))); - // } + #[tokio::test] + async fn test_call() { + let mut srv = pipeline(apply_fn(Srv, |req: &'static str, srv| { + let fut = srv.call(()); + async move { + let res = fut.await.unwrap(); + Ok((req, res)) + } + })); - // #[tokio::test] - // async fn test_new_service() { - // let new_srv = ApplyNewService::new( - // || ok::<_, ()>(Srv), - // |req: &'static str, srv| srv.call(()).map_ok(move |res| (req, res)), - // ); + assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(()))); - // let mut srv = new_srv.new_service(&()).await.unwrap(); + let res = srv.call("srv").await; + assert!(res.is_ok()); + assert_eq!(res.unwrap(), (("srv", ()))); + } - // assert_eq!(srv.poll_once().await, Poll::Ready(Ok(()))); - // let res = srv.call("srv").await; - // assert!(res.is_ok()); - // assert_eq!(res.unwrap(), (("srv", ()))); - // } + #[tokio::test] + async fn test_new_service() { + let new_srv = pipeline_factory(apply_fn_factory( + || ok::<_, ()>(Srv), + |req: &'static str, srv| { + let fut = srv.call(()); + async move { + let res = fut.await.unwrap(); + Ok((req, res)) + } + }, + )); + + let mut srv = new_srv.new_service(&()).await.unwrap(); + + assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(()))); + + let res = srv.call("srv").await; + assert!(res.is_ok()); + assert_eq!(res.unwrap(), (("srv", ()))); + } } diff --git a/actix-service/src/map.rs b/actix-service/src/map.rs index 9d8cf72a..f877293a 100644 --- a/actix-service/src/map.rs +++ b/actix-service/src/map.rs @@ -197,10 +197,10 @@ where #[cfg(test)] mod tests { - use futures::future::{ok, Ready}; + use futures::future::{lazy, ok, Ready}; use super::*; - use crate::{IntoServiceFactory, Service}; + use crate::{into_factory, into_service, Service}; struct Srv; @@ -210,7 +210,7 @@ mod tests { type Error = (); type Future = Ready>; - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { + fn poll_ready(&mut self, _: &mut Context) -> Poll> { Poll::Ready(Ok(())) } @@ -219,28 +219,27 @@ mod tests { } } - // #[tokio::test] - // async fn test_poll_ready() { - // let mut srv = Srv.map(|_| "ok"); - // let res = srv.poll_once().await; - // assert_eq!(res, Poll::Ready(Ok(()))); - // } + #[tokio::test] + async fn test_poll_ready() { + let mut srv = into_service(Srv).map(|_| "ok"); + let res = lazy(|cx| srv.poll_ready(cx)).await; + assert_eq!(res, Poll::Ready(Ok(()))); + } - // #[tokio::test] - // async fn test_call() { - // let mut srv = Srv.map(|_| "ok"); - // let res = srv.call(()).await; - // assert!(res.is_ok()); - // assert_eq!(res.unwrap(), "ok"); - // } + #[tokio::test] + async fn test_call() { + let mut srv = into_service(Srv).map(|_| "ok"); + let res = srv.call(()).await; + assert!(res.is_ok()); + assert_eq!(res.unwrap(), "ok"); + } - // #[tokio::test] - // async fn test_new_service() { - // let blank = || ok::<_, ()>(Srv); - // let new_srv = blank.into_new_service().map(|_| "ok"); - // let mut srv = new_srv.new_service(&()).await.unwrap(); - // let res = srv.call(()).await; - // assert!(res.is_ok()); - // assert_eq!(res.unwrap(), ("ok")); - // } + #[tokio::test] + async fn test_new_service() { + let new_srv = into_factory(|| ok::<_, ()>(Srv)).map(|_| "ok"); + let mut srv = new_srv.new_service(&()).await.unwrap(); + let res = srv.call(()).await; + assert!(res.is_ok()); + assert_eq!(res.unwrap(), ("ok")); + } } diff --git a/actix-service/src/map_err.rs b/actix-service/src/map_err.rs index b9424455..b76ad2af 100644 --- a/actix-service/src/map_err.rs +++ b/actix-service/src/map_err.rs @@ -201,56 +201,49 @@ where #[cfg(test)] mod tests { - // use futures::future::{err, Ready}; + use futures::future::{err, lazy, ok, Ready}; - // use super::*; - // use crate::{IntoNewService, NewService, Service}; - // use tokio::future::ok; + use super::*; + use crate::{into_factory, into_service, Service}; - // struct Srv; + struct Srv; - // impl Service for Srv { - // type Request = (); - // type Response = (); - // type Error = (); - // type Future = Ready>; + impl Service for Srv { + type Request = (); + type Response = (); + type Error = (); + type Future = Ready>; - // fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { - // Poll::Ready(Err(())) - // } + fn poll_ready(&mut self, _: &mut Context) -> Poll> { + Poll::Ready(Err(())) + } - // fn call(&mut self, _: ()) -> Self::Future { - // err(()) - // } - // } + fn call(&mut self, _: ()) -> Self::Future { + err(()) + } + } - // #[tokio::test] - // async fn test_poll_ready() { - // let mut srv = Srv.map_err(|_| "error"); - // let res = srv.poll_once().await; - // if let Poll::Ready(res) = res { - // assert!(res.is_err()); - // assert_eq!(res.err().unwrap(), "error"); - // } else { - // panic!("Should be ready"); - // } - // } + #[tokio::test] + async fn test_poll_ready() { + let mut srv = into_service(Srv).map_err(|_| "error"); + let res = lazy(|cx| srv.poll_ready(cx)).await; + assert_eq!(res, Poll::Ready(Err("error"))); + } - // #[tokio::test] - // async fn test_call() { - // let mut srv = Srv.map_err(|_| "error"); - // let res = srv.call(()).await; - // assert!(res.is_err()); - // assert_eq!(res.err().unwrap(), "error"); - // } + #[tokio::test] + async fn test_call() { + let mut srv = into_service(Srv).map_err(|_| "error"); + let res = srv.call(()).await; + assert!(res.is_err()); + assert_eq!(res.err().unwrap(), "error"); + } - // #[tokio::test] - // async fn test_new_service() { - // let blank = || ok::<_, ()>(Srv); - // let new_srv = blank.into_new_service().map_err(|_| "error"); - // let mut srv = new_srv.new_service(&()).await.unwrap(); - // let res = srv.call(()).await; - // assert!(res.is_err()); - // assert_eq!(res.err().unwrap(), "error"); - // } + #[tokio::test] + async fn test_new_service() { + let new_srv = into_factory(|| ok::<_, ()>(Srv)).map_err(|_| "error"); + let mut srv = new_srv.new_service(&()).await.unwrap(); + let res = srv.call(()).await; + assert!(res.is_err()); + assert_eq!(res.err().unwrap(), "error"); + } } diff --git a/actix-service/src/then.rs b/actix-service/src/then.rs index 2e23adb3..8fbbe1e5 100644 --- a/actix-service/src/then.rs +++ b/actix-service/src/then.rs @@ -265,7 +265,7 @@ mod tests { use std::rc::Rc; use std::task::{Context, Poll}; - use futures::future::{err, ok, ready, Ready}; + use futures::future::{err, lazy, ok, ready, Ready}; use crate::{pipeline, pipeline_factory, Service, ServiceFactory}; @@ -312,14 +312,14 @@ mod tests { } } - // #[tokio::test] - // async fn test_poll_ready() { - // let cnt = Rc::new(Cell::new(0)); - // let mut srv = pipeline(Srv1(cnt.clone())).then(Srv2(cnt.clone())); - // let res = srv.poll_ready().await; - // assert_eq!(res, Poll::Ready(Err(()))); - // assert_eq!(cnt.get(), 2); - // } + #[tokio::test] + async fn test_poll_ready() { + let cnt = Rc::new(Cell::new(0)); + let mut srv = pipeline(Srv1(cnt.clone())).then(Srv2(cnt.clone())); + let res = lazy(|cx| srv.poll_ready(cx)).await; + assert_eq!(res, Poll::Ready(Err(()))); + assert_eq!(cnt.get(), 2); + } #[tokio::test] async fn test_call() {