berkus
/
actix-net
mirror of https://github.com/fafhrd91/actix-net
1
0
Fork 0
Code Issues Releases Wiki Activity

restore service tests

This commit is contained in:
Nikolay Kim 2019-11-14 18:17:10 +06:00
parent e95f754817
commit ab22dcea68
6 changed files with 189 additions and 199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
actix-connect/src/ssl/openssl.rs
View File

@ -8,7 +8,6 @@ use actix_codec::{AsyncRead, AsyncWrite};
use actix_service::{Service, ServiceFactory}; use actix_service::{Service, ServiceFactory};
use futures::future::{err, ok, Either, FutureExt, LocalBoxFuture, Ready}; use futures::future::{err, ok, Either, FutureExt, LocalBoxFuture, Ready};
use open_ssl::ssl::SslConnector; use open_ssl::ssl::SslConnector;
use pin_project::pin_project;
use tokio_net::tcp::TcpStream; use tokio_net::tcp::TcpStream;
use tokio_openssl::{HandshakeError, SslStream}; use tokio_openssl::{HandshakeError, SslStream};
use trust_dns_resolver::AsyncResolver; use trust_dns_resolver::AsyncResolver;
@ -124,9 +123,7 @@ where
} }
} }
#[pin_project]
pub struct ConnectAsyncExt<T, U> { pub struct ConnectAsyncExt<T, U> {
#[pin]
fut: LocalBoxFuture<'static, Result<SslStream<U>, HandshakeError<U>>>, fut: LocalBoxFuture<'static, Result<SslStream<U>, HandshakeError<U>>>,
stream: Option<Connection<T, ()>>, stream: Option<Connection<T, ()>>,
_t: PhantomData<U>, _t: PhantomData<U>,
@ -139,9 +136,9 @@ where
type Output = Result<Connection<T, SslStream<U>>, io::Error>; type Output = Result<Connection<T, SslStream<U>>, io::Error>;
fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> { fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
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)) => { Poll::Ready(Ok(stream)) => {
let s = this.stream.take().unwrap(); let s = this.stream.take().unwrap();
trace!("SSL Handshake success: {:?}", s.host()); trace!("SSL Handshake success: {:?}", s.host());

134
actix-service/src/and_then.rs
View File

@ -251,86 +251,80 @@ where
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
// use futures::future::{ok, poll_fn, ready, Ready}; use std::cell::Cell;
// use futures::Poll; use std::rc::Rc;
// use std::cell::Cell; use std::task::{Context, Poll};
// use std::rc::Rc;
// use super::*; use futures::future::{lazy, ok, ready, Ready};
// use crate::{NewService, Service, ServiceExt};
// struct Srv1(Rc<Cell<usize>>); use crate::{factory_fn, pipeline, pipeline_factory, Service, ServiceFactory};
// impl Service for Srv1 { struct Srv1(Rc<Cell<usize>>);
// type Request = &'static str;
// type Response = &'static str;
// type Error = ();
// type Future = Ready<Result<Self::Response, ()>>;
// fn poll_ready( impl Service for Srv1 {
// self: Pin<&mut Self>, type Request = &'static str;
// cx: &mut Context<'_>, type Response = &'static str;
// ) -> Poll<Result<(), Self::Error>> { type Error = ();
// self.0.set(self.0.get() + 1); type Future = Ready<Result<Self::Response, ()>>;
// Poll::Ready(Ok(()))
// }
// fn call(&mut self, req: &'static str) -> Self::Future { fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
// ok(req) self.0.set(self.0.get() + 1);
// } Poll::Ready(Ok(()))
// } }
// #[derive(Clone)] fn call(&mut self, req: &'static str) -> Self::Future {
// struct Srv2(Rc<Cell<usize>>); ok(req)
}
}
// impl Service for Srv2 { #[derive(Clone)]
// type Request = &'static str; struct Srv2(Rc<Cell<usize>>);
// type Response = (&'static str, &'static str);
// type Error = ();
// type Future = Ready<Result<Self::Response, ()>>;
// fn poll_ready( impl Service for Srv2 {
// self: Pin<&mut Self>, type Request = &'static str;
// cx: &mut Context<'_>, type Response = (&'static str, &'static str);
// ) -> Poll<Result<(), Self::Error>> { type Error = ();
// self.0.set(self.0.get() + 1); type Future = Ready<Result<Self::Response, ()>>;
// Poll::Ready(Ok(()))
// }
// fn call(&mut self, req: &'static str) -> Self::Future { fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
// ok((req, "srv2")) self.0.set(self.0.get() + 1);
// } Poll::Ready(Ok(()))
// } }
// #[tokio::test] fn call(&mut self, req: &'static str) -> Self::Future {
// async fn test_poll_ready() { ok((req, "srv2"))
// 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);
// }
// #[tokio::test] #[tokio::test]
// async fn test_call() { async fn test_poll_ready() {
// let cnt = Rc::new(Cell::new(0)); let cnt = Rc::new(Cell::new(0));
// let mut srv = Srv1(cnt.clone()).and_then(Srv2(cnt)); let mut srv = pipeline(Srv1(cnt.clone())).and_then(Srv2(cnt.clone()));
// let res = srv.call("srv1").await; let res = lazy(|cx| srv.poll_ready(cx)).await;
// assert!(res.is_ok()); assert_eq!(res, Poll::Ready(Ok(())));
// assert_eq!(res.unwrap(), (("srv1", "srv2"))); assert_eq!(cnt.get(), 2);
// } }
// #[tokio::test] #[tokio::test]
// async fn test_new_service() { async fn test_call() {
// let cnt = Rc::new(Cell::new(0)); let cnt = Rc::new(Cell::new(0));
// let cnt2 = cnt.clone(); let mut srv = pipeline(Srv1(cnt.clone())).and_then(Srv2(cnt));
// let blank = move || ready(Ok::<_, ()>(Srv1(cnt2.clone()))); let res = srv.call("srv1").await;
// let new_srv = blank assert!(res.is_ok());
// .into_new_service() assert_eq!(res.unwrap(), (("srv1", "srv2")));
// .and_then(move || ready(Ok(Srv2(cnt.clone())))); }
// let mut srv = new_srv.new_service(&()).await.unwrap();
// let res = srv.call("srv1").await; #[tokio::test]
// assert!(res.is_ok()); async fn test_new_service() {
// assert_eq!(res.unwrap(), ("srv1", "srv2")); 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"));
}
} }

99
actix-service/src/apply.rs
View File

@ -183,60 +183,67 @@ where
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
// use futures::future::{ok, Ready}; use std::task::{Context, Poll};
// use futures::{Future, Poll, TryFutureExt};
// use super::*; use futures::future::{lazy, ok, Ready};
// use crate::{IntoService, NewService, Service, ServiceExt};
// #[derive(Clone)] use super::*;
// struct Srv; use crate::{pipeline, pipeline_factory, Service, ServiceFactory};
// impl Service for Srv { #[derive(Clone)]
// type Request = (); struct Srv;
// type Response = ();
// type Error = ();
// type Future = Ready<Result<(), ()>>;
// fn poll_ready( impl Service for Srv {
// self: Pin<&mut Self>, type Request = ();
// ctx: &mut Context<'_>, type Response = ();
// ) -> Poll<Result<(), Self::Error>> { type Error = ();
// Poll::Ready(Ok(())) type Future = Ready<Result<(), ()>>;
// }
// fn call(&mut self, _: ()) -> Self::Future { fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
// ok(()) Poll::Ready(Ok(()))
// } }
// }
// #[tokio::test] fn call(&mut self, _: ()) -> Self::Future {
// async fn test_call() { ok(())
// let blank = |req| ok(req); }
}
// let mut srv = blank #[tokio::test]
// .into_service() async fn test_call() {
// .apply_fn(Srv, |req: &'static str, srv| { let mut srv = pipeline(apply_fn(Srv, |req: &'static str, srv| {
// srv.call(()).map_ok(move |res| (req, res)) let fut = srv.call(());
// }); async move {
// assert_eq!(srv.poll_once().await, Poll::Ready(Ok(()))); let res = fut.await.unwrap();
// let res = srv.call("srv").await; Ok((req, res))
// assert!(res.is_ok()); }
// assert_eq!(res.unwrap(), (("srv", ()))); }));
// }
// #[tokio::test] assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
// async fn test_new_service() {
// let new_srv = ApplyNewService::new(
// || ok::<_, ()>(Srv),
// |req: &'static str, srv| srv.call(()).map_ok(move |res| (req, res)),
// );
// 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(()))); #[tokio::test]
// let res = srv.call("srv").await; async fn test_new_service() {
// assert!(res.is_ok()); let new_srv = pipeline_factory(apply_fn_factory(
// assert_eq!(res.unwrap(), (("srv", ()))); || 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", ())));
}
} }

49
actix-service/src/map.rs
View File

@ -197,10 +197,10 @@ where
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use futures::future::{ok, Ready}; use futures::future::{lazy, ok, Ready};
use super::*; use super::*;
use crate::{IntoServiceFactory, Service}; use crate::{into_factory, into_service, Service};
struct Srv; struct Srv;
@ -210,7 +210,7 @@ mod tests {
type Error = (); type Error = ();
type Future = Ready<Result<(), ()>>; type Future = Ready<Result<(), ()>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
@ -219,28 +219,27 @@ mod tests {
} }
} }
// #[tokio::test] #[tokio::test]
// async fn test_poll_ready() { async fn test_poll_ready() {
// let mut srv = Srv.map(|_| "ok"); let mut srv = into_service(Srv).map(|_| "ok");
// let res = srv.poll_once().await; let res = lazy(|cx| srv.poll_ready(cx)).await;
// assert_eq!(res, Poll::Ready(Ok(()))); assert_eq!(res, Poll::Ready(Ok(())));
// } }
// #[tokio::test] #[tokio::test]
// async fn test_call() { async fn test_call() {
// let mut srv = Srv.map(|_| "ok"); let mut srv = into_service(Srv).map(|_| "ok");
// let res = srv.call(()).await; let res = srv.call(()).await;
// assert!(res.is_ok()); assert!(res.is_ok());
// assert_eq!(res.unwrap(), "ok"); assert_eq!(res.unwrap(), "ok");
// } }
// #[tokio::test] #[tokio::test]
// async fn test_new_service() { async fn test_new_service() {
// let blank = || ok::<_, ()>(Srv); let new_srv = into_factory(|| ok::<_, ()>(Srv)).map(|_| "ok");
// let new_srv = blank.into_new_service().map(|_| "ok"); let mut srv = new_srv.new_service(&()).await.unwrap();
// let mut srv = new_srv.new_service(&()).await.unwrap(); let res = srv.call(()).await;
// let res = srv.call(()).await; assert!(res.is_ok());
// assert!(res.is_ok()); assert_eq!(res.unwrap(), ("ok"));
// assert_eq!(res.unwrap(), ("ok")); }
// }
} }

81
actix-service/src/map_err.rs
View File

@ -201,56 +201,49 @@ where
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
// use futures::future::{err, Ready}; use futures::future::{err, lazy, ok, Ready};
// use super::*; use super::*;
// use crate::{IntoNewService, NewService, Service}; use crate::{into_factory, into_service, Service};
// use tokio::future::ok;
// struct Srv; struct Srv;
// impl Service for Srv { impl Service for Srv {
// type Request = (); type Request = ();
// type Response = (); type Response = ();
// type Error = (); type Error = ();
// type Future = Ready<Result<(), ()>>; type Future = Ready<Result<(), ()>>;
// fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
// Poll::Ready(Err(())) Poll::Ready(Err(()))
// } }
// fn call(&mut self, _: ()) -> Self::Future { fn call(&mut self, _: ()) -> Self::Future {
// err(()) err(())
// } }
// } }
// #[tokio::test] #[tokio::test]
// async fn test_poll_ready() { async fn test_poll_ready() {
// let mut srv = Srv.map_err(|_| "error"); let mut srv = into_service(Srv).map_err(|_| "error");
// let res = srv.poll_once().await; let res = lazy(|cx| srv.poll_ready(cx)).await;
// if let Poll::Ready(res) = res { assert_eq!(res, Poll::Ready(Err("error")));
// assert!(res.is_err()); }
// assert_eq!(res.err().unwrap(), "error");
// } else {
// panic!("Should be ready");
// }
// }
// #[tokio::test] #[tokio::test]
// async fn test_call() { async fn test_call() {
// let mut srv = Srv.map_err(|_| "error"); let mut srv = into_service(Srv).map_err(|_| "error");
// let res = srv.call(()).await; let res = srv.call(()).await;
// assert!(res.is_err()); assert!(res.is_err());
// assert_eq!(res.err().unwrap(), "error"); assert_eq!(res.err().unwrap(), "error");
// } }
// #[tokio::test] #[tokio::test]
// async fn test_new_service() { async fn test_new_service() {
// let blank = || ok::<_, ()>(Srv); let new_srv = into_factory(|| ok::<_, ()>(Srv)).map_err(|_| "error");
// let new_srv = blank.into_new_service().map_err(|_| "error"); let mut srv = new_srv.new_service(&()).await.unwrap();
// let mut srv = new_srv.new_service(&()).await.unwrap(); let res = srv.call(()).await;
// let res = srv.call(()).await; assert!(res.is_err());
// assert!(res.is_err()); assert_eq!(res.err().unwrap(), "error");
// assert_eq!(res.err().unwrap(), "error"); }
// }
} }

18
actix-service/src/then.rs
View File

@ -265,7 +265,7 @@ mod tests {
use std::rc::Rc; use std::rc::Rc;
use std::task::{Context, Poll}; 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}; use crate::{pipeline, pipeline_factory, Service, ServiceFactory};
@ -312,14 +312,14 @@ mod tests {
} }
} }
// #[tokio::test] #[tokio::test]
// async fn test_poll_ready() { async fn test_poll_ready() {
// let cnt = Rc::new(Cell::new(0)); let cnt = Rc::new(Cell::new(0));
// let mut srv = pipeline(Srv1(cnt.clone())).then(Srv2(cnt.clone())); let mut srv = pipeline(Srv1(cnt.clone())).then(Srv2(cnt.clone()));
// let res = srv.poll_ready().await; let res = lazy(|cx| srv.poll_ready(cx)).await;
// assert_eq!(res, Poll::Ready(Err(()))); assert_eq!(res, Poll::Ready(Err(())));
// assert_eq!(cnt.get(), 2); assert_eq!(cnt.get(), 2);
// } }
#[tokio::test] #[tokio::test]
async fn test_call() { async fn test_call() {