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 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<T, U> {
#[pin]
fut: LocalBoxFuture<'static, Result<SslStream<U>, HandshakeError<U>>>,
stream: Option<Connection<T, ()>>,
_t: PhantomData<U>,
@ -139,9 +136,9 @@ where
type Output = Result<Connection<T, SslStream<U>>, io::Error>;
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)) => {
let s = this.stream.take().unwrap();
trace!("SSL Handshake success: {:?}", s.host());

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

@ -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<Cell<usize>>);
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<Result<Self::Response, ()>>;
struct Srv1(Rc<Cell<usize>>);
// fn poll_ready(
// self: Pin<&mut Self>,
// cx: &mut Context<'_>,
// ) -> Poll<Result<(), Self::Error>> {
// 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<Result<Self::Response, ()>>;
// fn call(&mut self, req: &'static str) -> Self::Future {
// ok(req)
// }
// }
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.0.set(self.0.get() + 1);
Poll::Ready(Ok(()))
}
// #[derive(Clone)]
// struct Srv2(Rc<Cell<usize>>);
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<Result<Self::Response, ()>>;
#[derive(Clone)]
struct Srv2(Rc<Cell<usize>>);
// fn poll_ready(
// self: Pin<&mut Self>,
// cx: &mut Context<'_>,
// ) -> Poll<Result<(), Self::Error>> {
// 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<Result<Self::Response, ()>>;
// fn call(&mut self, req: &'static str) -> Self::Future {
// ok((req, "srv2"))
// }
// }
fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
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"));
}
}

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

@ -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<Result<(), ()>>;
#[derive(Clone)]
struct Srv;
// fn poll_ready(
// self: Pin<&mut Self>,
// ctx: &mut Context<'_>,
// ) -> Poll<Result<(), Self::Error>> {
// Poll::Ready(Ok(()))
// }
impl Service for Srv {
type Request = ();
type Response = ();
type Error = ();
type Future = Ready<Result<(), ()>>;
// fn call(&mut self, _: ()) -> Self::Future {
// ok(())
// }
// }
fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
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", ())));
}
}

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

@ -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<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(()))
}
@ -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"));
}
}

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

@ -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<Result<(), ()>>;
impl Service for Srv {
type Request = ();
type Response = ();
type Error = ();
type Future = Ready<Result<(), ()>>;
// fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
// Poll::Ready(Err(()))
// }
fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
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");
}
}

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

@ -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() {