actix/actix-net
1
0
Fork 0
mirror of https://github.com/fafhrd91/actix-net synced 2025-02-17 14:43:31 +01:00
Code Issues Releases Wiki Activity

update tests

Browse Source
This commit is contained in:
Nikolay Kim 2019-12-02 11:43:52 +06:00
parent d81e72cf06
commit a08b1eba87
9 changed files with 37 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
actix-connect/Cargo.toml
View File

@ -42,7 +42,6 @@ either = "1.5.2"
futures = "0.3.1" futures = "0.3.1"
http = { version = "0.1.17", optional = true } http = { version = "0.1.17", optional = true }
log = "0.4" log = "0.4"
tokio-net = "=0.2.0-alpha.6"
trust-dns-resolver = { version="0.18.0-alpha.1", default-features = false } trust-dns-resolver = { version="0.18.0-alpha.1", default-features = false }
# openssl # openssl
@ -58,4 +57,3 @@ webpki = { version = "0.21", optional = true }
[dev-dependencies] [dev-dependencies]
bytes = "0.4" bytes = "0.4"
actix-testing = { version="0.3.0-alpha.1" } actix-testing = { version="0.3.0-alpha.1" }
actix-server-config = "0.3.0-alpha.1"

2
actix-connect/src/connector.rs
View File

@ -6,9 +6,9 @@ use std::net::SocketAddr;
use std::pin::Pin; use std::pin::Pin;
use std::task::{Context, Poll}; use std::task::{Context, Poll};
use actix_rt::net::TcpStream;
use actix_service::{Service, ServiceFactory}; use actix_service::{Service, ServiceFactory};
use futures::future::{err, ok, BoxFuture, Either, FutureExt, Ready}; use futures::future::{err, ok, BoxFuture, Either, FutureExt, Ready};
use tokio_net::tcp::TcpStream;
use super::connect::{Address, Connect, Connection}; use super::connect::{Address, Connect, Connection};
use super::error::ConnectError; use super::error::ConnectError;

3
actix-connect/src/lib.rs
View File

@ -20,9 +20,8 @@ pub mod ssl;
#[cfg(feature = "uri")] #[cfg(feature = "uri")]
mod uri; mod uri;
use actix_rt::Arbiter; use actix_rt::{net::TcpStream, Arbiter};
use actix_service::{pipeline, pipeline_factory, Service, ServiceFactory}; use actix_service::{pipeline, pipeline_factory, Service, ServiceFactory};
use tokio_net::tcp::TcpStream;
pub use trust_dns_resolver::config::{ResolverConfig, ResolverOpts}; pub use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
pub use trust_dns_resolver::system_conf::read_system_conf; pub use trust_dns_resolver::system_conf::read_system_conf;

2
actix-connect/src/service.rs
View File

@ -2,10 +2,10 @@ use std::future::Future;
use std::pin::Pin; use std::pin::Pin;
use std::task::{Context, Poll}; use std::task::{Context, Poll};
use actix_rt::net::TcpStream;
use actix_service::{Service, ServiceFactory}; use actix_service::{Service, ServiceFactory};
use either::Either; use either::Either;
use futures::future::{ok, Ready}; use futures::future::{ok, Ready};
use tokio_net::tcp::TcpStream;
use trust_dns_resolver::AsyncResolver; use trust_dns_resolver::AsyncResolver;
use crate::connect::{Address, Connect, Connection}; use crate::connect::{Address, Connect, Connection};

26
actix-connect/tests/test_connect.rs
View File

@ -1,7 +1,7 @@
use std::io; use std::io;
use actix_codec::{BytesCodec, Framed}; use actix_codec::{BytesCodec, Framed};
use actix_server_config::Io; use actix_rt::net::TcpStream;
use actix_service::{service_fn, Service, ServiceFactory}; use actix_service::{service_fn, Service, ServiceFactory};
use actix_testing::TestServer; use actix_testing::TestServer;
use bytes::Bytes; use bytes::Bytes;
@ -14,9 +14,9 @@ use actix_connect::Connect;
#[actix_rt::test] #[actix_rt::test]
async fn test_string() { async fn test_string() {
let srv = TestServer::with(|| { let srv = TestServer::with(|| {
service_fn(|io: Io<tokio_net::tcp::TcpStream>| { service_fn(|io: TcpStream| {
async { async {
let mut framed = Framed::new(io.into_parts().0, BytesCodec); let mut framed = Framed::new(io, BytesCodec);
framed.send(Bytes::from_static(b"test")).await?; framed.send(Bytes::from_static(b"test")).await?;
Ok::<_, io::Error>(()) Ok::<_, io::Error>(())
} }
@ -33,9 +33,9 @@ async fn test_string() {
#[actix_rt::test] #[actix_rt::test]
async fn test_rustls_string() { async fn test_rustls_string() {
let srv = TestServer::with(|| { let srv = TestServer::with(|| {
service_fn(|io: Io<tokio_net::tcp::TcpStream>| { service_fn(|io: TcpStream| {
async { async {
let mut framed = Framed::new(io.into_parts().0, BytesCodec); let mut framed = Framed::new(io, BytesCodec);
framed.send(Bytes::from_static(b"test")).await?; framed.send(Bytes::from_static(b"test")).await?;
Ok::<_, io::Error>(()) Ok::<_, io::Error>(())
} }
@ -51,9 +51,9 @@ async fn test_rustls_string() {
#[actix_rt::test] #[actix_rt::test]
async fn test_static_str() { async fn test_static_str() {
let srv = TestServer::with(|| { let srv = TestServer::with(|| {
service_fn(|io: Io<tokio_net::tcp::TcpStream>| { service_fn(|io: TcpStream| {
async { async {
let mut framed = Framed::new(io.into_parts().0, BytesCodec); let mut framed = Framed::new(io, BytesCodec);
framed.send(Bytes::from_static(b"test")).await?; framed.send(Bytes::from_static(b"test")).await?;
Ok::<_, io::Error>(()) Ok::<_, io::Error>(())
} }
@ -75,9 +75,9 @@ async fn test_static_str() {
#[actix_rt::test] #[actix_rt::test]
async fn test_new_service() { async fn test_new_service() {
let srv = TestServer::with(|| { let srv = TestServer::with(|| {
service_fn(|io: Io<tokio_net::tcp::TcpStream>| { service_fn(|io: TcpStream| {
async { async {
let mut framed = Framed::new(io.into_parts().0, BytesCodec); let mut framed = Framed::new(io, BytesCodec);
framed.send(Bytes::from_static(b"test")).await?; framed.send(Bytes::from_static(b"test")).await?;
Ok::<_, io::Error>(()) Ok::<_, io::Error>(())
} }
@ -100,9 +100,9 @@ async fn test_uri() {
use http::HttpTryFrom; use http::HttpTryFrom;
let srv = TestServer::with(|| { let srv = TestServer::with(|| {
service_fn(|io: Io<tokio_net::tcp::TcpStream>| { service_fn(|io: TcpStream| {
async { async {
let mut framed = Framed::new(io.into_parts().0, BytesCodec); let mut framed = Framed::new(io, BytesCodec);
framed.send(Bytes::from_static(b"test")).await?; framed.send(Bytes::from_static(b"test")).await?;
Ok::<_, io::Error>(()) Ok::<_, io::Error>(())
} }
@ -121,9 +121,9 @@ async fn test_rustls_uri() {
use http::HttpTryFrom; use http::HttpTryFrom;
let srv = TestServer::with(|| { let srv = TestServer::with(|| {
service_fn(|io: Io<tokio_net::tcp::TcpStream>| { service_fn(|io: TcpStream| {
async { async {
let mut framed = Framed::new(io.into_parts().0, BytesCodec); let mut framed = Framed::new(io, BytesCodec);
framed.send(Bytes::from_static(b"test")).await?; framed.send(Bytes::from_static(b"test")).await?;
Ok::<_, io::Error>(()) Ok::<_, io::Error>(())
} }

2
actix-ioframe/Cargo.toml
View File

@ -31,5 +31,3 @@ log = "0.4"
[dev-dependencies] [dev-dependencies]
actix-connect = "1.0.0-alpha.1" actix-connect = "1.0.0-alpha.1"
actix-testing = "0.3.0-alpha.1" actix-testing = "0.3.0-alpha.1"
actix-server-config = "0.3.0-alpha.1"
tokio-net = "=0.2.0-alpha.6"

23
actix-ioframe/tests/test_server.rs
View File

@ -4,11 +4,9 @@ use std::time::Duration;
use actix_codec::BytesCodec; use actix_codec::BytesCodec;
use actix_rt::time::delay_for; use actix_rt::time::delay_for;
use actix_server_config::Io; use actix_service::{service_fn, Service};
use actix_service::{apply_fn_factory, service_fn, Service};
use actix_testing::TestServer; use actix_testing::TestServer;
use futures::future::ok; use futures::future::ok;
use tokio_net::tcp::TcpStream;
use actix_ioframe::{Builder, Connect}; use actix_ioframe::{Builder, Connect};
@ -22,17 +20,14 @@ async fn test_disconnect() -> std::io::Result<()> {
let srv = TestServer::with(move || { let srv = TestServer::with(move || {
let disconnect1 = disconnect1.clone(); let disconnect1 = disconnect1.clone();
apply_fn_factory( Builder::new()
Builder::new() .factory(service_fn(|conn: Connect<_>| {
.factory(service_fn(|conn: Connect<_>| { ok(conn.codec(BytesCodec).state(State))
ok(conn.codec(BytesCodec).state(State)) }))
})) .disconnect(move |_, _| {
.disconnect(move |_, _| { disconnect1.store(true, Ordering::Relaxed);
disconnect1.store(true, Ordering::Relaxed); })
}) .finish(service_fn(|_t| ok(None)))
.finish(service_fn(|_t| ok(None))),
|io: Io<TcpStream>, srv| srv.call(io.into_parts().0),
)
}); });
let mut client = Builder::new() let mut client = Builder::new()

58
actix-server/tests/test_server.rs
View File

@ -3,12 +3,12 @@ use std::sync::mpsc;
use std::{net, thread, time}; use std::{net, thread, time};
use actix_codec::{BytesCodec, Framed}; use actix_codec::{BytesCodec, Framed};
use actix_server::{Io, Server, ServerConfig}; use actix_rt::net::TcpStream;
use actix_service::{factory_fn_cfg, service_fn, service_fn2}; use actix_server::Server;
use actix_service::service_fn;
use bytes::Bytes; use bytes::Bytes;
use futures::{future::ok, SinkExt}; use futures::{future::ok, SinkExt};
use net2::TcpBuilder; use net2::TcpBuilder;
use tokio_net::tcp::TcpStream;
fn unused_addr() -> net::SocketAddr { fn unused_addr() -> net::SocketAddr {
let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap(); let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap();
@ -27,12 +27,7 @@ fn test_bind() {
let h = thread::spawn(move || { let h = thread::spawn(move || {
let sys = actix_rt::System::new("test"); let sys = actix_rt::System::new("test");
let srv = Server::build() let srv = Server::build()
.bind("test", addr, move || { .bind("test", addr, move || service_fn(|_| ok::<_, ()>(())))
factory_fn_cfg(move |cfg: &ServerConfig| {
assert_eq!(cfg.local_addr(), addr);
ok::<_, ()>(service_fn2(|_| ok::<_, ()>(())))
})
})
.unwrap() .unwrap()
.start(); .start();
let _ = tx.send((srv, actix_rt::System::current())); let _ = tx.send((srv, actix_rt::System::current()));
@ -46,26 +41,6 @@ fn test_bind() {
let _ = h.join(); let _ = h.join();
} }
#[test]
fn test_bind_no_config() {
let addr = unused_addr();
let (tx, rx) = mpsc::channel();
let h = thread::spawn(move || {
let sys = actix_rt::System::new("test");
let srv = Server::build()
.bind("test", addr, move || service_fn(|_| ok::<_, ()>(())))
.unwrap()
.start();
let _ = tx.send((srv, actix_rt::System::current()));
let _ = sys.run();
});
let (_, sys) = rx.recv().unwrap();
assert!(net::TcpStream::connect(addr).is_ok());
let _ = sys.stop();
let _ = h.join();
}
#[test] #[test]
fn test_listen() { fn test_listen() {
let addr = unused_addr(); let addr = unused_addr();
@ -75,12 +50,7 @@ fn test_listen() {
let sys = actix_rt::System::new("test"); let sys = actix_rt::System::new("test");
let lst = net::TcpListener::bind(addr).unwrap(); let lst = net::TcpListener::bind(addr).unwrap();
let srv = Server::build() let srv = Server::build()
.listen("test", lst, move || { .listen("test", lst, move || service_fn(|_| ok::<_, ()>(())))
factory_fn_cfg(move |cfg: &ServerConfig| {
assert_eq!(cfg.local_addr(), addr);
ok::<_, ()>(service_fn2(|_| ok::<_, ()>(())))
})
})
.unwrap() .unwrap()
.start(); .start();
let _ = tx.send((srv, actix_rt::System::current())); let _ = tx.send((srv, actix_rt::System::current()));
@ -105,18 +75,12 @@ fn test_start() {
let srv: Server = Server::build() let srv: Server = Server::build()
.backlog(100) .backlog(100)
.bind("test", addr, move || { .bind("test", addr, move || {
factory_fn_cfg(move |cfg: &ServerConfig| { service_fn(|io: TcpStream| {
assert_eq!(cfg.local_addr(), addr); async move {
let mut f = Framed::new(io, BytesCodec);
let srv = service_fn2(|io: Io<TcpStream>| { f.send(Bytes::from_static(b"test")).await.unwrap();
async { Ok::<_, ()>(())
let mut f = Framed::new(io.into_parts().0, BytesCodec); }
f.send(Bytes::from_static(b"test")).await.unwrap();
Ok::<_, ()>(())
}
});
ok::<_, ()>(srv)
}) })
}) })
.unwrap() .unwrap()

2
actix-testing/Cargo.toml
View File

@ -26,4 +26,4 @@ actix-service = "1.0.0-alpha.1"
log = "0.4" log = "0.4"
net2 = "0.2" net2 = "0.2"
futures = "0.3.1" futures = "0.3.1"
tokio-net = { version = "0.2.0-alpha.6" }