merge actix-codec

Cargo.toml

@@ -1,6 +1,7 @@
 [workspace]
 members = [
   "ntex",
+  "ntex-codec",
   "ntex-router",
   "ntex-service",
   "ntex-web-macros",
@@ -11,13 +12,13 @@ members = [
 
 [patch.crates-io]
 ntex = { path = "ntex" }
+ntex-codec = { path = "ntex-codec" }
 ntex-router = { path = "ntex-router" }
 ntex-service = { path = "ntex-service" }
 
 actix-service = { path = "actix-net/actix-service" }
 actix-router = { path = "actix-net/router" }
 
-actix-codec = { path = "actix-net/actix-codec" }
 actix-rt = { path = "actix-net/actix-rt" }
 actix-macros = { path = "actix-net/actix-macros" }
 bytestring = { path = "actix-net/string" }

actix-net/actix-codec/Cargo.toml

@@ -2,24 +2,22 @@
 name = "actix-codec"
 version = "0.2.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Utilities for encoding and decoding frames"
+description = "Actix codec"
 keywords = ["network", "framework", "async", "futures"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-net.git"
-documentation = "https://docs.rs/actix-codec/"
+documentation = "https://docs.rs/actix-service/"
 categories = ["network-programming", "asynchronous"]
 license = "MIT/Apache-2.0"
 edition = "2018"
 
+[badges]
+travis-ci = { repository = "actix/actix-service", branch = "master" }
+codecov = { repository = "actix/actix-service", branch = "master", service = "github" }
+
 [lib]
 name = "actix_codec"
 path = "src/lib.rs"
 
 [dependencies]
-bitflags = "1.2.1"
-bytes = "0.5.2"
-futures-core = "0.3.1"
-futures-sink = "0.3.1"
-tokio = { version = "0.2.4", default-features=false }
-tokio-util = { version = "0.2.0", default-features=false, features=["codec"] }
-log = "0.4"
+ntex-codec = "0.3.0"

actix-net/actix-codec/src/lib.rs

@@ -1,18 +1 @@
-//! Utilities for encoding and decoding frames.
-//!
-//! Contains adapters to go from streams of bytes, [`AsyncRead`] and
-//! [`AsyncWrite`], to framed streams implementing [`Sink`] and [`Stream`].
-//! Framed streams are also known as [transports].
-//!
-//! [`AsyncRead`]: #
-//! [`AsyncWrite`]: #
-#![deny(rust_2018_idioms, warnings)]
-
-mod bcodec;
-mod framed;
-
-pub use self::bcodec::BytesCodec;
-pub use self::framed::{Framed, FramedParts};
-
-pub use tokio::io::{AsyncRead, AsyncWrite};
-pub use tokio_util::codec::{Decoder, Encoder};
+pub use ntex_codec::*;

ntex-codec/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "ntex-codec"
+version = "0.1.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Utilities for encoding and decoding frames"
+keywords = ["network", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/ntex-rs/ntex.git"
+documentation = "https://docs.rs/ntex-codec/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT/Apache-2.0"
+edition = "2018"
+
+[lib]
+name = "ntex_codec"
+path = "src/lib.rs"
+
+[dependencies]
+bitflags = "1.2.1"
+bytes = "0.5.2"
+futures-core = "0.3.1"
+futures-sink = "0.3.1"
+tokio = { version = "0.2.4", default-features=false }
+tokio-util = { version = "0.2.0", default-features=false, features=["codec"] }
+log = "0.4"

ntex-codec/src/framed.rs

@@ -185,7 +185,10 @@ impl<T, U> Framed<T, U> {
 
 impl<T, U> Framed<T, U> {
     /// Serialize item and Write to the inner buffer
-    pub fn write(&mut self, item: <U as Encoder>::Item) -> Result<(), <U as Encoder>::Error>
+    pub fn write(
+        &mut self,
+        item: <U as Encoder>::Item,
+    ) -> Result<(), <U as Encoder>::Error>
     where
         T: AsyncWrite,
         U: Encoder,
@@ -207,7 +210,10 @@ impl<T, U> Framed<T, U> {
     }
 
     /// Try to read underlying I/O stream and decode item.
-    pub fn next_item(&mut self, cx: &mut Context<'_>) -> Poll<Option<Result<U::Item, U::Error>>>
+    pub fn next_item(
+        &mut self,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<U::Item, U::Error>>>
     where
         T: AsyncRead,
         U: Decoder,
@@ -319,7 +325,10 @@ where
 {
     type Item = Result<U::Item, U::Error>;
 
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
         self.next_item(cx)
     }
 }
@@ -332,7 +341,10 @@ where
 {
     type Error = U::Error;
 
-    fn poll_ready(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
         if self.is_write_ready() {
             Poll::Ready(Ok(()))
         } else {

ntex-codec/src/lib.rs

@@ -0,0 +1,18 @@
+//! Utilities for encoding and decoding frames.
+//!
+//! Contains adapters to go from streams of bytes, [`AsyncRead`] and
+//! [`AsyncWrite`], to framed streams implementing [`Sink`] and [`Stream`].
+//! Framed streams are also known as [transports].
+//!
+//! [`AsyncRead`]: #
+//! [`AsyncWrite`]: #
+#![deny(rust_2018_idioms, warnings)]
+
+mod bcodec;
+mod framed;
+
+pub use self::bcodec::BytesCodec;
+pub use self::framed::{Framed, FramedParts};
+
+pub use tokio::io::{AsyncRead, AsyncWrite};
+pub use tokio_util::codec::{Decoder, Encoder};

ntex-web-macros/Cargo.toml

@@ -16,6 +16,5 @@ syn = { version = "^1", features = ["full", "parsing"] }
 proc-macro2 = "^1"
 
 [dev-dependencies]
-actix-rt = "1.0.0"
 ntex = { path = "../ntex/" }
 futures = { version = "0.3.1" }

ntex/Cargo.toml

@@ -36,11 +36,11 @@ compress = ["flate2", "brotli2"]
 cookie = ["coo-kie", "coo-kie/percent-encode"]
 
 [dependencies]
+ntex-codec = { path = "../ntex-codec" }
 ntex-router = { path = "../ntex-router" }
 ntex-service = { path = "../ntex-service" }
 ntex-web-macros = { path = "../ntex-web-macros" }
 
-actix-codec = "0.2.0"
 actix-macros = "0.1.0"
 actix-rt = "1.0.0"
 actix-threadpool = "0.3.1"
@@ -99,7 +99,6 @@ flate2 = { version = "1.0.13", optional = true }
 tokio = "0.2.4"
 
 [dev-dependencies]
-actix-connect = { version = "1.0.0", features=["openssl"] }
 futures = "0.3.1"
 env_logger = "0.7"
 serde_derive = "1.0"

ntex/src/channel/condition.rs

@@ -98,7 +98,7 @@ mod tests {
     use super::*;
     use futures::future::lazy;
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_condition() {
         let mut cond = Condition::new();
         let mut waiter = cond.wait();

ntex/src/channel/mpsc.rs

@@ -195,7 +195,7 @@ mod tests {
     use futures::future::lazy;
     use futures::{Stream, StreamExt};
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_mpsc() {
         let (tx, mut rx) = channel();
         tx.send("test").unwrap();

ntex/src/channel/oneshot.rs

@@ -255,7 +255,7 @@ mod tests {
     use super::*;
     use futures::future::lazy;
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_oneshot() {
         let (tx, rx) = channel();
         tx.send("test").unwrap();
@@ -282,7 +282,7 @@ mod tests {
         assert!(rx.await.is_err());
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_pool() {
         let (tx, rx) = pool().channel();
         tx.send("test").unwrap();

ntex/src/codec.rs

@@ -0,0 +1,2 @@
+//! Utilities for encoding and decoding frames.
+pub use ntex_codec::*;

ntex/src/connect/mod.rs

@@ -36,7 +36,7 @@ pub use self::service::Connector;
 
 pub fn start_resolver(cfg: ResolverConfig, opts: ResolverOpts) -> AsyncResolver {
     let (resolver, bg) = AsyncResolver::new(cfg, opts);
-    actix_rt::spawn(bg);
+    crate::rt::spawn(bg);
     resolver
 }
 
@@ -55,7 +55,7 @@ pub(crate) fn get_default_resolver() -> AsyncResolver {
         };
 
         let (resolver, bg) = AsyncResolver::new(cfg, opts);
-        actix_rt::spawn(bg);
+        crate::rt::spawn(bg);
 
         Arbiter::set_item(DefaultResolver(resolver.clone()));
         resolver

ntex/src/framed/connect.rs

@@ -2,10 +2,10 @@ use std::marker::PhantomData;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
-use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
 use futures::Stream;
 
 use crate::channel::mpsc::Receiver;
+use crate::codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
 
 pub struct Connect<Io, Codec>
 where

ntex/src/framed/dispatcher.rs

@@ -2,11 +2,11 @@
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
-use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
 use futures::Stream;
 use log::debug;
 
 use crate::channel::mpsc;
+use crate::codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
 use crate::service::Service;
 
 use super::error::ServiceError;
@@ -113,7 +113,7 @@ where
 
                     let tx = self.rx.sender();
                     let fut = self.service.call(item);
-                    actix_rt::spawn(async move {
+                    crate::rt::spawn(async move {
                         let item = fut.await;
                         let item = match item {
                             Ok(Some(item)) => Ok(item),

ntex/src/framed/error.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 
-use actix_codec::{Decoder, Encoder};
+use crate::codec::{Decoder, Encoder};
 
 /// Framed service errors
 pub enum ServiceError<E, U: Encoder + Decoder> {

ntex/src/framed/service.rs

@@ -4,11 +4,11 @@ use std::pin::Pin;
 use std::rc::Rc;
 use std::task::{Context, Poll};
 
-use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
 use either::Either;
 use futures::{ready, Stream};
 use pin_project::project;
 
+use crate::codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
 use crate::service::{IntoService, IntoServiceFactory, Service, ServiceFactory};
 
 use super::connect::{Connect, ConnectResult};

ntex/src/framed/transport.rs

@@ -4,14 +4,15 @@ use std::mem;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
-use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
 use futures::{Future, FutureExt, Stream};
 use log::debug;
 
-use super::error::ServiceError;
 use crate::channel::mpsc;
+use crate::codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
 use crate::service::{IntoService, Service};
 
+use super::error::ServiceError;
+
 type Request<U> = <U as Decoder>::Item;
 type Response<U> = <U as Encoder>::Item;
 
@@ -156,7 +157,7 @@ where
                     };
 
                     let tx = self.tx.clone();
-                    actix_rt::spawn(self.service.call(item).map(move |item| {
+                    crate::rt::spawn(self.service.call(item).map(move |item| {
                         let _ = tx.send(item.map(Message::Item));
                     }));
                 }

ntex/src/http/body.rs

@@ -573,7 +573,7 @@ mod tests {
         );
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_bytes() {
         let mut b = Bytes::from("test");
         assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
@@ -586,7 +586,7 @@ mod tests {
         );
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_bytes_mut() {
         let mut b = BytesMut::from("test");
         assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
@@ -599,7 +599,7 @@ mod tests {
         );
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_string() {
         let mut b = "test".to_owned();
         assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
@@ -614,20 +614,20 @@ mod tests {
         );
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_unit() {
         assert_eq!(().size(), BodySize::Empty);
         assert!(poll_fn(|cx| ().poll_next_chunk(cx)).await.is_none());
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_box() {
         let mut val = Box::new(());
         assert_eq!(val.size(), BodySize::Empty);
         assert!(poll_fn(|cx| val.poll_next_chunk(cx)).await.is_none());
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_body_eq() {
         assert!(Body::None == Body::None);
         assert!(Body::None != Body::Empty);
@@ -640,14 +640,14 @@ mod tests {
         assert!(Body::Bytes(Bytes::from_static(b"1")) != Body::None);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_body_debug() {
         assert!(format!("{:?}", Body::None).contains("Body::None"));
         assert!(format!("{:?}", Body::Empty).contains("Body::Empty"));
         assert!(format!("{:?}", Body::Bytes(Bytes::from_static(b"1"))).contains("1"));
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_serde_json() {
         use serde_json::json;
         assert_eq!(
@@ -663,7 +663,7 @@ mod tests {
     mod body_stream {
         use super::*;
 
-        #[actix_rt::test]
+        #[crate::test]
         async fn skips_empty_chunks() {
             let mut body = BodyStream::new(stream::iter(
                 ["1", "", "2"]
@@ -684,7 +684,7 @@ mod tests {
     mod sized_stream {
         use super::*;
 
-        #[actix_rt::test]
+        #[crate::test]
         async fn skips_empty_chunks() {
             let mut body = SizedStream::new(
                 2,

ntex/src/http/builder.rs

@@ -2,8 +2,7 @@ use std::marker::PhantomData;
 use std::rc::Rc;
 use std::{fmt, net};
 
-use actix_codec::Framed;
-
+use crate::codec::Framed;
 use crate::http::body::MessageBody;
 use crate::http::config::{KeepAlive, ServiceConfig};
 use crate::http::error::ResponseError;

ntex/src/http/client/connect.rs

@@ -4,8 +4,7 @@ use std::rc::Rc;
 use std::task::{Context, Poll};
 use std::{fmt, io, mem, net};
 
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-
+use crate::codec::{AsyncRead, AsyncWrite, Framed};
 use crate::http::body::Body;
 use crate::http::h1::ClientCodec;
 use crate::http::{HeaderMap, RequestHead, RequestHeadType, ResponseHead};

ntex/src/http/client/connection.rs

@@ -1,10 +1,10 @@
 use std::{fmt, time};
 
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
 use bytes::Bytes;
 use futures::future::{err, Either, Future, FutureExt, LocalBoxFuture, Ready};
 use h2::client::SendRequest;
 
+use crate::codec::{AsyncRead, AsyncWrite, Framed};
 use crate::http::body::MessageBody;
 use crate::http::h1::ClientCodec;
 use crate::http::message::{RequestHeadType, ResponseHead};

ntex/src/http/client/connector.rs

@@ -3,9 +3,9 @@ use std::rc::Rc;
 use std::task::{Context, Poll};
 use std::time::Duration;
 
-use actix_codec::{AsyncRead, AsyncWrite};
 use futures::future::{err, Either, Ready};
 
+use crate::codec::{AsyncRead, AsyncWrite};
 use crate::connect::{Connect as TcpConnect, Connector as TcpConnector};
 use crate::http::{Protocol, Uri};
 use crate::service::{apply_fn, boxed, Service};

ntex/src/http/client/h1proto.rs

@@ -3,12 +3,12 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 use std::{io, mem, time};
 
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
 use bytes::buf::BufMutExt;
 use bytes::{Bytes, BytesMut};
 use futures::future::poll_fn;
 use futures::{SinkExt, Stream, StreamExt};
 
+use crate::codec::{AsyncRead, AsyncWrite, Framed};
 use crate::http::body::{BodySize, MessageBody};
 use crate::http::error::PayloadError;
 use crate::http::h1;

ntex/src/http/client/h2proto.rs

@@ -1,13 +1,13 @@
 use std::convert::TryFrom;
 use std::time;
 
-use actix_codec::{AsyncRead, AsyncWrite};
 use bytes::Bytes;
 use futures::future::poll_fn;
 use h2::{client::SendRequest, SendStream};
 use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, TRANSFER_ENCODING};
 use http::{request::Request, Method, Version};
 
+use crate::codec::{AsyncRead, AsyncWrite};
 use crate::http::body::{BodySize, MessageBody};
 use crate::http::header::HeaderMap;
 use crate::http::message::{RequestHeadType, ResponseHead};

ntex/src/http/client/pool.rs

@@ -6,8 +6,6 @@ use std::rc::Rc;
 use std::task::{Context, Poll};
 use std::time::{Duration, Instant};
 
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_rt::time::{delay_for, Delay};
 use bytes::Bytes;
 use futures::future::{poll_fn, FutureExt, LocalBoxFuture};
 use fxhash::FxHashMap;
@@ -17,7 +15,9 @@ use indexmap::IndexSet;
 use slab::Slab;
 
 use crate::channel::oneshot;
+use crate::codec::{AsyncRead, AsyncWrite};
 use crate::http::Protocol;
+use crate::rt::time::{delay_for, Delay};
 use crate::service::Service;
 use crate::task::LocalWaker;
 

ntex/src/http/client/response.rs

@@ -381,7 +381,7 @@ mod tests {
     use crate::http::client::test::TestResponse;
     use crate::http::header;
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_body() {
         let mut req = TestResponse::with_header(header::CONTENT_LENGTH, "xxxx").finish();
         match req.body().await.err().unwrap() {
@@ -429,7 +429,7 @@ mod tests {
         }
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_json_body() {
         let mut req = TestResponse::default().finish();
         let json = JsonBody::<_, MyObject>::new(&mut req).await;

ntex/src/http/client/ws.rs

@@ -4,18 +4,17 @@ use std::net::SocketAddr;
 use std::rc::Rc;
 use std::{fmt, str};
 
-use actix_codec::Framed;
-use actix_rt::time::timeout;
-
 #[cfg(feature = "cookie")]
 use coo_kie::{Cookie, CookieJar};
 
+use crate::codec::Framed;
 use crate::http::error::HttpError;
 use crate::http::header::{
     self, HeaderName, HeaderValue, IntoHeaderValue, AUTHORIZATION,
 };
 use crate::http::{ConnectionType, Method, StatusCode, Uri, Version};
 use crate::http::{Payload, RequestHead};
+use crate::rt::time::timeout;
 use crate::ws;
 
 use super::connect::BoxedSocket;
@@ -411,7 +410,7 @@ mod tests {
     use super::*;
     use crate::http::client::Client;
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_debug() {
         let request = Client::new().ws("/").header("x-test", "111");
         let repr = format!("{:?}", request);
@@ -419,7 +418,7 @@ mod tests {
         assert!(repr.contains("x-test"));
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_header_override() {
         let req = Client::build()
             .header(header::CONTENT_TYPE, "111")
@@ -438,7 +437,7 @@ mod tests {
         );
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn basic_auth() {
         let req = Client::new()
             .ws("/")
@@ -465,7 +464,7 @@ mod tests {
         );
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn bearer_auth() {
         let req = Client::new().ws("/").bearer_auth("someS3cr3tAutht0k3n");
         assert_eq!(
@@ -481,7 +480,7 @@ mod tests {
     }
 
     #[cfg(feature = "cookie")]
-    #[actix_rt::test]
+    #[crate::test]
     async fn basics() {
         let req = Client::new()
             .ws("http://localhost/")

ntex/src/http/config.rs

@@ -4,11 +4,12 @@ use std::rc::Rc;
 use std::time::Duration;
 use std::{fmt, net};
 
-use actix_rt::time::{delay_for, delay_until, Delay, Instant};
 use bytes::BytesMut;
 use futures::{future, FutureExt};
 use time::OffsetDateTime;
 
+use crate::rt::time::{delay_for, delay_until, Delay, Instant};
+
 // "Sun, 06 Nov 1994 08:49:37 GMT".len()
 const DATE_VALUE_LENGTH: usize = 29;
 
@@ -292,7 +293,7 @@ mod tests {
         assert_eq!(DATE_VALUE_LENGTH, "Sun, 06 Nov 1994 08:49:37 GMT".len());
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_date() {
         let settings = ServiceConfig::new(KeepAlive::Os, 0, 0, false, None);
         let mut buf1 = BytesMut::with_capacity(DATE_VALUE_LENGTH + 10);

ntex/src/http/error.rs

@@ -4,7 +4,6 @@ use std::str::Utf8Error;
 use std::string::FromUtf8Error;
 use std::{fmt, io};
 
-use actix_codec::{Decoder, Encoder};
 use derive_more::{Display, From};
 use http::uri::InvalidUri;
 use http::{header, StatusCode};
@@ -15,6 +14,7 @@ pub use actix_threadpool::BlockingError;
 pub use futures::channel::oneshot::Canceled;
 pub use http::Error as HttpError;
 
+use crate::codec::{Decoder, Encoder};
 use crate::framed::ServiceError as FramedDispatcherError;
 
 use super::body::Body;

ntex/src/http/h1/client.rs

@@ -1,14 +1,14 @@
 use std::io;
 
-use actix_codec::{Decoder, Encoder};
 use bitflags::bitflags;
 use bytes::{Bytes, BytesMut};
-use http::{Method, Version};
 
+use crate::codec::{Decoder, Encoder};
 use crate::http::body::BodySize;
 use crate::http::config::ServiceConfig;
 use crate::http::error::{ParseError, PayloadError};
 use crate::http::message::{ConnectionType, RequestHeadType, ResponseHead};
+use crate::http::{Method, Version};
 
 use super::decoder::{PayloadDecoder, PayloadItem, PayloadType};
 use super::{decoder, encoder, reserve_readbuf};

ntex/src/http/h1/codec.rs

@@ -1,10 +1,10 @@
 use std::{fmt, io};
 
-use actix_codec::{Decoder, Encoder};
 use bitflags::bitflags;
 use bytes::BytesMut;
 use http::{Method, Version};
 
+use crate::codec::{Decoder, Encoder};
 use crate::http::body::BodySize;
 use crate::http::config::ServiceConfig;
 use crate::http::error::ParseError;

ntex/src/http/h1/decoder.rs

@@ -4,13 +4,13 @@ use std::marker::PhantomData;
 use std::mem::MaybeUninit;
 use std::task::Poll;
 
-use actix_codec::Decoder;
 use bytes::{Buf, Bytes, BytesMut};
 use http::header::{HeaderName, HeaderValue};
 use http::{header, Method, StatusCode, Uri, Version};
 use httparse;
 use log::{debug, error, trace};
 
+use crate::codec::Decoder;
 use crate::http::error::ParseError;
 use crate::http::header::HeaderMap;
 use crate::http::message::{ConnectionType, ResponseHead};

ntex/src/http/h1/dispatcher.rs

@@ -4,12 +4,11 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 use std::{fmt, io, net};
 
-use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed, FramedParts};
-use actix_rt::time::{delay_until, Delay, Instant};
 use bitflags::bitflags;
 use bytes::{Buf, BytesMut};
 use log::{error, trace};
 
+use crate::codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed, FramedParts};
 use crate::http::body::{Body, BodySize, MessageBody, ResponseBody};
 use crate::http::cloneable::CloneableService;
 use crate::http::config::ServiceConfig;
@@ -18,6 +17,7 @@ use crate::http::error::{ParseError, PayloadError};
 use crate::http::helpers::DataFactory;
 use crate::http::request::Request;
 use crate::http::response::Response;
+use crate::rt::time::{delay_until, Delay, Instant};
 use crate::Service;
 
 use super::codec::Codec;
@@ -913,7 +913,7 @@ mod tests {
     use crate::http::test::TestBuffer;
     use crate::IntoService;
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_req_parse_err() {
         lazy(|cx| {
             let buf = TestBuffer::new("GET /test HTTP/1\r\n\r\n");

ntex/src/http/h1/payload.rs

@@ -228,7 +228,7 @@ mod tests {
     use super::*;
     use futures::future::poll_fn;
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_unread_data() {
         let (_, mut payload) = Payload::create(false);
 

ntex/src/http/h1/service.rs

@@ -5,11 +5,10 @@ use std::rc::Rc;
 use std::task::{Context, Poll};
 use std::{fmt, net};
 
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use actix_rt::net::TcpStream;
 use futures::future::{ok, Ready};
 use futures::ready;
 
+use crate::codec::{AsyncRead, AsyncWrite, Framed};
 use crate::http::body::MessageBody;
 use crate::http::cloneable::CloneableService;
 use crate::http::config::ServiceConfig;
@@ -17,6 +16,7 @@ use crate::http::error::{DispatchError, ParseError, ResponseError};
 use crate::http::helpers::DataFactory;
 use crate::http::request::Request;
 use crate::http::response::Response;
+use crate::rt::net::TcpStream;
 use crate::{pipeline_factory, IntoServiceFactory, Service, ServiceFactory};
 
 use super::codec::Codec;

ntex/src/http/h1/upgrade.rs

@@ -2,9 +2,9 @@ use std::io;
 use std::marker::PhantomData;
 use std::task::{Context, Poll};
 
-use actix_codec::Framed;
 use futures::future::Ready;
 
+use crate::codec::Framed;
 use crate::http::h1::Codec;
 use crate::http::request::Request;
 use crate::{Service, ServiceFactory};

ntex/src/http/h1/utils.rs

@@ -3,8 +3,7 @@ use std::future::Future;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-
+use crate::codec::{AsyncRead, AsyncWrite, Framed};
 use crate::http::body::{BodySize, MessageBody, ResponseBody};
 use crate::http::h1::{Codec, Message};
 use crate::http::response::Response;

ntex/src/http/h2/dispatcher.rs

@@ -5,14 +5,13 @@ use std::net;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_rt::time::{Delay, Instant};
 use bytes::{Bytes, BytesMut};
 use h2::server::{Connection, SendResponse};
 use h2::SendStream;
 use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING};
 use log::{error, trace};
 
+use crate::codec::{AsyncRead, AsyncWrite};
 use crate::http::body::{BodySize, MessageBody, ResponseBody};
 use crate::http::cloneable::CloneableService;
 use crate::http::config::ServiceConfig;
@@ -22,6 +21,7 @@ use crate::http::message::ResponseHead;
 use crate::http::payload::Payload;
 use crate::http::request::Request;
 use crate::http::response::Response;
+use crate::rt::time::{Delay, Instant};
 use crate::Service;
 
 const CHUNK_SIZE: usize = 16_384;

ntex/src/http/h2/service.rs

@@ -4,14 +4,13 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 use std::{net, rc};
 
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_rt::net::TcpStream;
 use bytes::Bytes;
 use futures::future::ok;
 use futures::ready;
 use h2::server::{self, Handshake};
 use log::error;
 
+use crate::codec::{AsyncRead, AsyncWrite};
 use crate::http::body::MessageBody;
 use crate::http::cloneable::CloneableService;
 use crate::http::config::ServiceConfig;
@@ -19,6 +18,7 @@ use crate::http::error::{DispatchError, ResponseError};
 use crate::http::helpers::DataFactory;
 use crate::http::request::Request;
 use crate::http::response::Response;
+use crate::rt::net::TcpStream;
 use crate::{
     fn_factory, fn_service, pipeline_factory, IntoServiceFactory, Service,
     ServiceFactory,

ntex/src/http/service.rs

@@ -3,14 +3,14 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 use std::{fmt, net, rc};
 
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use actix_rt::net::TcpStream;
 use bytes::Bytes;
 use futures::future::ok;
 use futures::{ready, Future};
 use h2::server::{self, Handshake};
 use pin_project::{pin_project, project};
 
+use crate::codec::{AsyncRead, AsyncWrite, Framed};
+use crate::rt::net::TcpStream;
 use crate::service::{pipeline_factory, IntoServiceFactory, Service, ServiceFactory};
 
 use super::body::MessageBody;

ntex/src/http/test.rs

@@ -7,13 +7,13 @@ use std::sync::mpsc;
 use std::task::{Context, Poll};
 use std::{net, thread, time};
 
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
 use bytes::{Bytes, BytesMut};
 use futures::Stream;
 
 #[cfg(feature = "cookie")]
 use coo_kie::{Cookie, CookieJar};
 
+use crate::codec::{AsyncRead, AsyncWrite, Framed};
 use crate::rt::{net::TcpStream, System};
 use crate::server::{Server, ServiceFactory};
 

ntex/src/lib.rs

@@ -18,6 +18,7 @@ extern crate log;
 pub use actix_macros::{main, test};
 
 pub mod channel;
+pub mod codec;
 pub mod connect;
 pub mod framed;
 pub mod http;

ntex/src/server/openssl.rs

@@ -6,9 +6,9 @@ use std::task::{Context, Poll};
 pub use open_ssl::ssl::{AlpnError, SslAcceptor, SslAcceptorBuilder};
 pub use tokio_openssl::{HandshakeError, SslStream};
 
-use actix_codec::{AsyncRead, AsyncWrite};
 use futures::future::{ok, FutureExt, LocalBoxFuture, Ready};
 
+use crate::codec::{AsyncRead, AsyncWrite};
 use crate::service::{Service, ServiceFactory};
 use crate::util::counter::{Counter, CounterGuard};
 

ntex/src/server/rustls.rs

@@ -5,7 +5,6 @@ use std::pin::Pin;
 use std::sync::Arc;
 use std::task::{Context, Poll};
 
-use actix_codec::{AsyncRead, AsyncWrite};
 use futures::future::{ok, Ready};
 use tokio_rustls::{Accept, TlsAcceptor};
 
@@ -13,6 +12,7 @@ pub use rust_tls::{ServerConfig, Session};
 pub use tokio_rustls::server::TlsStream;
 pub use webpki_roots::TLS_SERVER_ROOTS;
 
+use crate::codec::{AsyncRead, AsyncWrite};
 use crate::service::{Service, ServiceFactory};
 use crate::util::counter::{Counter, CounterGuard};
 

ntex/src/server/socket.rs

@@ -1,7 +1,7 @@
 use std::{fmt, io, net};
 
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_rt::net::TcpStream;
+use crate::codec::{AsyncRead, AsyncWrite};
+use crate::rt::net::TcpStream;
 
 pub(crate) enum StdListener {
     Tcp(net::TcpListener),

ntex/src/util/framed.rs

@@ -4,11 +4,11 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 use std::{fmt, mem};
 
-use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
 use futures::{Future, FutureExt, Stream};
 use log::debug;
 
 use crate::channel::mpsc;
+use crate::codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
 use crate::service::{IntoService, Service};
 
 type Request<U> = <U as Decoder>::Item;
@@ -205,7 +205,7 @@ where
                     };
 
                     let tx = self.tx.clone();
-                    actix_rt::spawn(self.service.call(item).map(move |item| {
+                    crate::rt::spawn(self.service.call(item).map(move |item| {
                         let _ = tx.send(item.map(Message::Item));
                     }));
                 }

ntex/src/util/inflight.rs

@@ -134,13 +134,13 @@ mod tests {
         }
 
         fn call(&mut self, _: ()) -> Self::Future {
-            actix_rt::time::delay_for(self.0)
+            crate::rt::time::delay_for(self.0)
                 .then(|_| ok::<_, ()>(()))
                 .boxed_local()
         }
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_transform() {
         let wait_time = Duration::from_millis(50);
 
@@ -154,7 +154,7 @@ mod tests {
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_newtransform() {
         let wait_time = Duration::from_millis(50);
 

ntex/src/util/order.rs

@@ -236,7 +236,7 @@ mod tests {
         }
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_inorder() {
         let (tx1, rx1) = oneshot::channel();
         let (tx2, rx2) = oneshot::channel();

ntex/src/util/time.rs

@@ -161,7 +161,7 @@ mod tests {
     /// State Under Test: Two calls of `SystemTimeService::now()` return the same value if they are done within resolution interval of `SystemTimeService`.
     ///
     /// Expected Behavior: Two back-to-back calls of `SystemTimeService::now()` return the same value.
-    #[actix_rt::test]
+    #[crate::test]
     async fn system_time_service_time_does_not_immediately_change() {
         let resolution = Duration::from_millis(50);
 
@@ -172,7 +172,7 @@ mod tests {
     /// State Under Test: Two calls of `LowResTimeService::now()` return the same value if they are done within resolution interval of `SystemTimeService`.
     ///
     /// Expected Behavior: Two back-to-back calls of `LowResTimeService::now()` return the same value.
-    #[actix_rt::test]
+    #[crate::test]
     async fn lowres_time_service_time_does_not_immediately_change() {
         let resolution = Duration::from_millis(50);
         let time_service = LowResTimeService::with(resolution);
@@ -183,7 +183,7 @@ mod tests {
     ///
     /// Expected Behavior: Two calls of `LowResTimeService::now()` made in subsequent resolution interval return different values
     /// and second value is greater than the first one at least by a resolution interval.
-    #[actix_rt::test]
+    #[crate::test]
     async fn system_time_service_time_updates_after_resolution_interval() {
         let resolution = Duration::from_millis(100);
         let wait_time = Duration::from_millis(300);
@@ -209,7 +209,7 @@ mod tests {
     ///
     /// Expected Behavior: Two calls of `LowResTimeService::now()` made in subsequent resolution interval return different values
     /// and second value is greater than the first one at least by a resolution interval.
-    #[actix_rt::test]
+    #[crate::test]
     async fn lowres_time_service_time_updates_after_resolution_interval() {
         let resolution = Duration::from_millis(100);
         let wait_time = Duration::from_millis(300);

ntex/src/util/timeout.rs

@@ -209,7 +209,7 @@ mod tests {
         }
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_success() {
         let resolution = Duration::from_millis(100);
         let wait_time = Duration::from_millis(50);
@@ -218,7 +218,7 @@ mod tests {
         assert_eq!(timeout.call(()).await, Ok(()));
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_timeout() {
         let resolution = Duration::from_millis(100);
         let wait_time = Duration::from_millis(500);
@@ -227,7 +227,7 @@ mod tests {
         assert_eq!(timeout.call(()).await, Err(TimeoutError::Timeout));
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_timeout_newservice() {
         let resolution = Duration::from_millis(100);
         let wait_time = Duration::from_millis(500);

ntex/src/web/app.rs

@@ -527,7 +527,7 @@ mod tests {
     use crate::web::{self, DefaultError, HttpRequest, HttpResponse};
     use crate::Service;
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_default_resource() {
         let mut srv = init_service(
             App::new()
@@ -573,7 +573,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::CREATED);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_data_factory() {
         let mut srv = init_service(
             App::new().data_factory(|| ok::<_, ()>(10usize)).service(
@@ -598,7 +598,7 @@ mod tests {
         assert_eq!(res.status(), StatusCode::INTERNAL_SERVER_ERROR);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_extension() {
         let mut srv = init_service(App::new().app_data(10usize).service(
             web::resource("/").to(|req: HttpRequest| async move {
@@ -612,7 +612,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_wrap() {
         let mut srv = init_service(
             App::new()
@@ -632,7 +632,7 @@ mod tests {
         );
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_router_wrap() {
         let mut srv = init_service(
             App::new()
@@ -652,7 +652,7 @@ mod tests {
         );
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_wrap_fn() {
         let mut srv = init_service(
             App::new()
@@ -679,7 +679,7 @@ mod tests {
         );
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_router_wrap_fn() {
         let mut srv = init_service(
             App::new()
@@ -706,7 +706,7 @@ mod tests {
         );
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_case_insensitive_router() {
         let mut srv = init_service(
             App::new()
@@ -723,7 +723,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_external_resource() {
         let mut srv = init_service(
             App::new()

ntex/src/web/app_service.rs

@@ -492,7 +492,7 @@ mod tests {
         }
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_drop_data() {
         let data = Arc::new(AtomicBool::new(false));
 

ntex/src/web/config.rs

@@ -249,7 +249,7 @@ mod tests {
     use crate::web::{self, App, HttpRequest, HttpResponse};
     use crate::Service;
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_data() {
         let cfg = |cfg: &mut ServiceConfig<_>| {
             cfg.data(10usize);
@@ -264,7 +264,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
-    // #[actix_rt::test]
+    // #[crate::test]
     // async fn test_data_factory() {
     //     let cfg = |cfg: &mut ServiceConfig| {
     //         cfg.data_factory(|| {
@@ -296,7 +296,7 @@ mod tests {
     //     assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
     // }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_external_resource() {
         let mut srv = init_service(
             App::new()
@@ -324,7 +324,7 @@ mod tests {
         assert_eq!(body, Bytes::from_static(b"https://youtube.com/watch/12345"));
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_service() {
         let mut srv = init_service(App::new().configure(|cfg| {
             cfg.service(

ntex/src/web/data.rs

@@ -140,7 +140,7 @@ mod tests {
     use crate::web::{self, App, HttpResponse};
     use crate::Service;
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_data_extractor() {
         let mut srv = init_service(App::new().data("TEST".to_string()).service(
             web::resource("/").to(|data: web::Data<String>| async move {
@@ -163,7 +163,7 @@ mod tests {
         assert_eq!(res.status(), StatusCode::INTERNAL_SERVER_ERROR);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_app_data_extractor() {
         let mut srv = init_service(App::new().app_data(Data::new(10usize)).service(
             web::resource("/").to(|_: web::Data<usize>| async { HttpResponse::Ok() }),
@@ -183,7 +183,7 @@ mod tests {
         assert_eq!(res.status(), StatusCode::INTERNAL_SERVER_ERROR);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_route_data_extractor() {
         let mut srv =
             init_service(App::new().service(web::resource("/").data(10usize).route(
@@ -209,7 +209,7 @@ mod tests {
         assert_eq!(res.status(), StatusCode::INTERNAL_SERVER_ERROR);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_override_data() {
         let mut srv = init_service(App::new().data(1usize).service(
             web::resource("/").data(10usize).route(web::get().to(
@@ -227,7 +227,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_data_drop() {
         struct TestData(Arc<AtomicUsize>);
 

ntex/src/web/extract.rs

@@ -280,7 +280,7 @@ tuple_from_req!(TupleFromRequest10, (0, A), (1, B), (2, C), (3, D), (4, E), (5,
 //         extract
 //     }
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_option() {
 //         let (req, mut pl) = TestRequest::with_header(
 //             header::CONTENT_TYPE,
@@ -326,7 +326,7 @@ tuple_from_req!(TupleFromRequest10, (0, A), (1, B), (2, C), (3, D), (4, E), (5,
 //         assert_eq!(r, None);
 //     }
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_result() {
 //         let (req, mut pl) = TestRequest::with_header(
 //             header::CONTENT_TYPE,

ntex/src/web/middleware/cors.rs

@@ -827,13 +827,13 @@ mod tests {
 
     use super::*;
 
-    #[actix_rt::test]
+    #[crate::test]
     #[should_panic(expected = "Credentials are allowed, but the Origin is set to")]
     async fn cors_validates_illegal_allow_credentials() {
         let _cors = Cors::new().supports_credentials().send_wildcard().finish();
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn validate_origin_allows_all_origins() {
         let mut cors = Cors::new()
             .finish()
@@ -847,7 +847,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn default() {
         let mut cors = Cors::default()
             .new_transform(test::ok_service())
@@ -860,7 +860,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_preflight() {
         let mut cors = Cors::new()
             .send_wildcard()
@@ -950,7 +950,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
-    // #[actix_rt::test]
+    // #[crate::test]
     // #[should_panic(expected = "MissingOrigin")]
     // async fn test_validate_missing_origin() {
     //    let cors = Cors::build()
@@ -960,7 +960,7 @@ mod tests {
     //    cors.start(&req).unwrap();
     // }
 
-    #[actix_rt::test]
+    #[crate::test]
     #[should_panic(expected = "OriginNotAllowed")]
     async fn test_validate_not_allowed_origin() {
         let cors = Cors::new()
@@ -978,7 +978,7 @@ mod tests {
         cors.inner.validate_allowed_headers(req.head()).unwrap();
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_validate_origin() {
         let mut cors = Cors::new()
             .allowed_origin("https://www.example.com")
@@ -995,7 +995,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_no_origin_response() {
         let mut cors = Cors::new()
             .disable_preflight()
@@ -1024,7 +1024,7 @@ mod tests {
         );
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_response() {
         let exposed_headers = vec![header::AUTHORIZATION, header::ACCEPT];
         let mut cors = Cors::new()
@@ -1124,7 +1124,7 @@ mod tests {
         assert_eq!("https://www.example.com", origins_str);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_multiple_origins() {
         let mut cors = Cors::new()
             .allowed_origin("https://example.com")
@@ -1162,7 +1162,7 @@ mod tests {
         );
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_multiple_origins_preflight() {
         let mut cors = Cors::new()
             .allowed_origin("https://example.com")

ntex/src/web/middleware/defaultheaders.rs

@@ -170,7 +170,7 @@ mod tests {
     use crate::web::test::{ok_service, TestRequest};
     use crate::web::{DefaultError, Error, HttpResponse};
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_default_headers() {
         let mut mw = DefaultHeaders::<DefaultError>::new()
             .header(CONTENT_TYPE, "0001")
@@ -198,7 +198,7 @@ mod tests {
         assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0002");
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_content_type() {
         let srv = |req: WebRequest<DefaultError>| {
             ok::<_, Error>(req.into_response(HttpResponse::Ok().finish()))

ntex/src/web/middleware/logger.rs

@@ -490,7 +490,7 @@ mod tests {
     use crate::web::test::TestRequest;
     use crate::web::{DefaultError, Error};
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_logger() {
         let srv = |req: WebRequest<DefaultError>| {
             ok::<_, Error>(
@@ -515,7 +515,7 @@ mod tests {
         let _res = srv.call(req).await;
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_url_path() {
         let mut format = Format::new("%T %U");
         let req = TestRequest::with_header(
@@ -545,7 +545,7 @@ mod tests {
         assert!(s.contains("/test/route/yeah"));
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_default_format() {
         let mut format = Format::default();
 
@@ -578,7 +578,7 @@ mod tests {
         assert!(s.contains("ACTIX-WEB"));
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_request_time_format() {
         let mut format = Format::new("%t");
         let req = TestRequest::default().to_srv_request();

ntex/src/web/request.rs

@@ -460,7 +460,7 @@ mod tests {
         );
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_data() {
         let mut srv = init_service(App::new().app_data(10usize).service(
             web::resource("/").to(|req: HttpRequest| {
@@ -493,7 +493,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_extensions_dropped() {
         struct Tracker {
             dropped: bool,

ntex/src/web/resource.rs

@@ -569,7 +569,7 @@ mod tests {
     use crate::web::{self, guard, App, DefaultError, Error, HttpResponse};
     use crate::Service;
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_middleware() {
         let mut srv =
             init_service(
@@ -593,7 +593,7 @@ mod tests {
         );
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_middleware_fn() {
         let mut srv = init_service(
             App::new().service(
@@ -623,7 +623,7 @@ mod tests {
         );
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_to() {
         let mut srv =
             init_service(App::new().service(web::resource("/test").to(|| async {
@@ -636,7 +636,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_pattern() {
         let mut srv = init_service(App::new().service(
             web::resource(["/test", "/test2"]).to(|| async { HttpResponse::Ok() }),
@@ -650,7 +650,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_default_resource() {
         let mut srv = init_service(
             App::new()
@@ -695,7 +695,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_resource_guards() {
         let mut srv = init_service(
             App::new()
@@ -736,7 +736,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::NO_CONTENT);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_data() {
         let mut srv = init_service(
             App::new()

ntex/src/web/responder.rs

@@ -485,7 +485,7 @@ pub(crate) mod tests {
         responder
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_option_responder() {
         let mut srv = init_service(
             web::App::new()
@@ -512,7 +512,7 @@ pub(crate) mod tests {
         }
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_responder() {
         let req = TestRequest::default().to_http_request();
 
@@ -585,7 +585,7 @@ pub(crate) mod tests {
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_result_responder() {
         let req = TestRequest::default().to_http_request();
 
@@ -612,7 +612,7 @@ pub(crate) mod tests {
         assert!(res.is_err());
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_custom_responder() {
         let req = TestRequest::default().to_http_request();
         let res = responder("test".to_string())
@@ -637,7 +637,7 @@ pub(crate) mod tests {
         );
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_tuple_responder_with_status_code() {
         let req = TestRequest::default().to_http_request();
         let res = Responder::<DefaultError>::respond_to(

ntex/src/web/route.rs

@@ -219,7 +219,7 @@ mod tests {
         name: String,
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_route() {
         let mut srv = init_service(
             App::new()

ntex/src/web/scope.rs

@@ -689,7 +689,7 @@ mod tests {
     use crate::web::DefaultError;
     use crate::web::{self, guard, App, HttpRequest, HttpResponse};
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_scope() {
         let mut srv =
             init_service(App::new().service(
@@ -704,7 +704,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_scope_root() {
         let mut srv = init_service(
             App::new().service(
@@ -726,7 +726,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::CREATED);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_scope_root2() {
         let mut srv = init_service(
             App::new().service(
@@ -745,7 +745,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_scope_root3() {
         let mut srv = init_service(
             App::new().service(
@@ -764,7 +764,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_scope_route() {
         let mut srv = init_service(
             App::new().service(
@@ -792,7 +792,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::NOT_FOUND);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_scope_route_without_leading_slash() {
         let mut srv = init_service(
             App::new().service(
@@ -822,7 +822,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_scope_guard() {
         let mut srv =
             init_service(App::new().service(
@@ -845,7 +845,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_scope_variable_segment() {
         let mut srv =
             init_service(App::new().service(web::scope("/ab-{project}").service(
@@ -873,7 +873,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::NOT_FOUND);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_nested_scope() {
         let mut srv = init_service(App::new().service(web::scope("/app").service(
             web::scope("/t1").service(
@@ -887,7 +887,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::CREATED);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_nested_scope_no_slash() {
         let mut srv = init_service(App::new().service(web::scope("/app").service(
             web::scope("t1").service(
@@ -901,7 +901,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::CREATED);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_nested_scope_root() {
         let mut srv = init_service(
             App::new().service(
@@ -925,7 +925,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::CREATED);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_nested_scope_filter() {
         let mut srv =
             init_service(App::new().service(web::scope("/app").service(
@@ -948,7 +948,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_nested_scope_with_variable_segment() {
         let mut srv = init_service(App::new().service(web::scope("/app").service(
             web::scope("/{project_id}").service(web::resource("/path1").to(
@@ -973,7 +973,7 @@ mod tests {
         }
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_nested2_scope_with_variable_segment() {
         let mut srv = init_service(App::new().service(web::scope("/app").service(
             web::scope("/{project}").service(web::scope("/{id}").service(
@@ -1005,7 +1005,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::NOT_FOUND);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_default_resource() {
         let mut srv = init_service(
             App::new().service(
@@ -1027,7 +1027,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::NOT_FOUND);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_default_resource_propagation() {
         let mut srv = init_service(
             App::new()
@@ -1054,7 +1054,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_middleware() {
         let mut srv = init_service(
             App::new().service(
@@ -1080,7 +1080,7 @@ mod tests {
         );
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_middleware_fn() {
         let mut srv = init_service(
             App::new().service(
@@ -1108,7 +1108,7 @@ mod tests {
         );
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_override_data() {
         let mut srv = init_service(App::new().data(1usize).service(
             web::scope("app").data(10usize).route(
@@ -1127,7 +1127,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_override_app_data() {
         let mut srv = init_service(App::new().app_data(web::Data::new(1usize)).service(
             web::scope("app").app_data(web::Data::new(10usize)).route(
@@ -1146,7 +1146,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_scope_config() {
         let mut srv =
             init_service(App::new().service(web::scope("/app").configure(|s| {
@@ -1159,7 +1159,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_scope_config_2() {
         let mut srv =
             init_service(App::new().service(web::scope("/app").configure(|s| {
@@ -1174,7 +1174,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_url_for_external() {
         let mut srv =
             init_service(App::new().service(web::scope("/app").configure(|s| {
@@ -1203,7 +1203,7 @@ mod tests {
         assert_eq!(body, &b"https://youtube.com/watch/xxxxxx"[..]);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_url_for_nested() {
         let mut srv = init_service(App::new().service(web::scope("/a").service(
             web::scope("/b").service(web::resource("/c/{stuff}").name("c").route(

ntex/src/web/service.rs

@@ -600,7 +600,7 @@ mod tests {
         assert!(WebRequest::<DefaultError>::from_request(r).is_err());
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_service() {
         let mut srv = init_service(App::new().service(
             web::service("/test").name("test").finish(

ntex/src/web/test.rs

@@ -6,8 +6,6 @@ use std::rc::Rc;
 use std::sync::mpsc;
 use std::{fmt, net, thread, time};
 
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use actix_rt::{time::delay_for, System};
 use bytes::{Bytes, BytesMut};
 use futures::future::ok;
 use futures::stream::{Stream, StreamExt};
@@ -19,6 +17,7 @@ use serde_json;
 #[cfg(feature = "cookie")]
 use coo_kie::Cookie;
 
+use crate::codec::{AsyncRead, AsyncWrite, Framed};
 use crate::http::body::{Body, MessageBody};
 use crate::http::client::error::WsClientError;
 use crate::http::client::{Client, ClientRequest, ClientResponse, Connector};
@@ -29,6 +28,7 @@ use crate::http::{
     Extensions, HttpService, Method, Payload, Request, StatusCode, Uri, Version,
 };
 use crate::router::{Path, ResourceDef};
+use crate::rt::{time::delay_for, System};
 use crate::server::Server;
 use crate::{map_config, IntoService, IntoServiceFactory, Service, ServiceFactory};
 
@@ -957,7 +957,7 @@ mod tests {
     use crate::http::HttpMessage;
     use crate::web::{self, App, Data, Error, HttpResponse};
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_basics() {
         let req = TestRequest::with_header(header::CONTENT_TYPE, "application/json")
             .version(Version::HTTP_2)
@@ -978,7 +978,7 @@ mod tests {
         assert_eq!(*data.get_ref(), 20);
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_request_methods() {
         let mut app = init_service(
             App::new().service(
@@ -1016,7 +1016,7 @@ mod tests {
         assert_eq!(result, Bytes::from_static(b"delete!"));
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_response() {
         let mut app =
             init_service(App::new().service(web::resource("/index.html").route(
@@ -1039,7 +1039,7 @@ mod tests {
         name: String,
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_response_json() {
         let mut app = init_service(App::new().service(web::resource("/people").route(
             web::post().to(|person: web::types::Json<Person>| async {
@@ -1060,7 +1060,7 @@ mod tests {
         assert_eq!(&result.id, "12345");
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_request_response_form() {
         let mut app = init_service(App::new().service(web::resource("/people").route(
             web::post().to(|person: web::types::Form<Person>| async {
@@ -1086,7 +1086,7 @@ mod tests {
         assert_eq!(&result.name, "User name");
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_request_response_json() {
         let mut app = init_service(App::new().service(web::resource("/people").route(
             web::post().to(|person: web::types::Json<Person>| async {
@@ -1112,7 +1112,7 @@ mod tests {
         assert_eq!(&result.name, "User name");
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_async_with_block() {
         async fn async_with_block() -> Result<HttpResponse, Error> {
             let res = web::block(move || Some(4usize).ok_or("wrong")).await;
@@ -1138,7 +1138,7 @@ mod tests {
         assert!(res.status().is_success());
     }
 
-    #[actix_rt::test]
+    #[crate::test]
     async fn test_server_data() {
         async fn handler(data: web::Data<usize>) -> crate::http::ResponseBuilder {
             assert_eq!(**data, 10);

ntex/src/web/types/form.rs

@@ -362,7 +362,7 @@ where
 //         counter: i64,
 //     }
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_form() {
 //         let (req, mut pl) =
 //             TestRequest::with_header(CONTENT_TYPE, "application/x-www-form-urlencoded")
@@ -398,7 +398,7 @@ where
 //         }
 //     }
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_urlencoded_error() {
 //         let (req, mut pl) =
 //             TestRequest::with_header(CONTENT_TYPE, "application/x-www-form-urlencoded")
@@ -424,7 +424,7 @@ where
 //         assert!(eq(info.err().unwrap(), UrlencodedError::ContentType));
 //     }
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_urlencoded() {
 //         let (req, mut pl) =
 //             TestRequest::with_header(CONTENT_TYPE, "application/x-www-form-urlencoded")
@@ -459,7 +459,7 @@ where
 //         );
 //     }
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_responder() {
 //         let req = TestRequest::default().to_http_request();
 

ntex/src/web/types/json.rs

@@ -414,7 +414,7 @@ where
 //         }
 //     }
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_responder() {
 //         let req = TestRequest::default().to_http_request();
 
@@ -431,7 +431,7 @@ where
 //         assert_eq!(resp.body().bin_ref(), b"{\"name\":\"test\"}");
 //     }
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_custom_error_responder() {
 //         let (req, mut pl) = TestRequest::default()
 //             .header(
@@ -462,7 +462,7 @@ where
 //         assert_eq!(msg.name, "invalid request");
 //     }
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_extract() {
 //         let (req, mut pl) = TestRequest::default()
 //             .header(
@@ -522,7 +522,7 @@ where
 //         assert!(format!("{}", s.err().unwrap()).contains("Content type error"));
 //     }
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_json_body() {
 //         let (req, mut pl) = TestRequest::default().to_http_parts();
 //         let json = JsonBody::<MyObject>::new(&req, &mut pl, None).await;
@@ -574,7 +574,7 @@ where
 //         );
 //     }
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_with_json_and_bad_content_type() {
 //         let (req, mut pl) = TestRequest::with_header(
 //             header::CONTENT_TYPE,
@@ -592,7 +592,7 @@ where
 //         assert!(s.is_err())
 //     }
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_with_json_and_good_custom_content_type() {
 //         let (req, mut pl) = TestRequest::with_header(
 //             header::CONTENT_TYPE,
@@ -612,7 +612,7 @@ where
 //         assert!(s.is_ok())
 //     }
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_with_json_and_bad_custom_content_type() {
 //         let (req, mut pl) = TestRequest::with_header(
 //             header::CONTENT_TYPE,

ntex/src/web/types/path.rs

@@ -202,7 +202,7 @@ where
 //         value: u32,
 //     }
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_extract_path_single() {
 //         let resource = ResourceDef::new("/{value}/");
 
@@ -214,7 +214,7 @@ where
 //         assert!(Path::<MyStruct>::from_request(&req, &mut pl).await.is_err());
 //     }
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_tuple_extract() {
 //         let resource = ResourceDef::new("/{key}/{value}/");
 
@@ -241,7 +241,7 @@ where
 //         let () = <()>::from_request(&req, &mut pl).await.unwrap();
 //     }
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_request_extract() {
 //         let mut req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
 
@@ -289,7 +289,7 @@ where
 //         assert_eq!(res[1], "32".to_owned());
 //     }
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_custom_err_handler() {
 //         let (req, mut pl) = TestRequest::with_uri("/name/user1/")
 //             .data(PathConfig::default().error_handler(|err, _| {

ntex/src/web/types/payload.rs

@@ -422,7 +422,7 @@ impl Future for HttpMessageBody {
 //     use crate::http::header;
 //     use crate::web::test::TestRequest;
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_payload_config() {
 //         let req = TestRequest::default().to_http_request();
 //         let cfg = PayloadConfig::default().mimetype(mime::APPLICATION_JSON);
@@ -440,7 +440,7 @@ impl Future for HttpMessageBody {
 //         assert!(cfg.check_mimetype(&req).is_ok());
 //     }
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_bytes() {
 //         let (req, mut pl) = TestRequest::with_header(header::CONTENT_LENGTH, "11")
 //             .set_payload(Bytes::from_static(b"hello=world"))
@@ -450,7 +450,7 @@ impl Future for HttpMessageBody {
 //         assert_eq!(s, Bytes::from_static(b"hello=world"));
 //     }
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_string() {
 //         let (req, mut pl) = TestRequest::with_header(header::CONTENT_LENGTH, "11")
 //             .set_payload(Bytes::from_static(b"hello=world"))
@@ -460,7 +460,7 @@ impl Future for HttpMessageBody {
 //         assert_eq!(s, "hello=world");
 //     }
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_message_body() {
 //         let (req, mut pl) = TestRequest::with_header(header::CONTENT_LENGTH, "xxxx")
 //             .to_srv_request()

ntex/src/web/types/query.rs

@@ -169,7 +169,7 @@ where
 //         id: String,
 //     }
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_service_request_extract() {
 //         let req = TestRequest::with_uri("/name/user1/").to_srv_request();
 //         assert!(Query::<Id>::from_query(&req.query_string()).is_err());
@@ -185,7 +185,7 @@ where
 //         assert_eq!(s.id, "test1");
 //     }
 
-//     #[actix_rt::test]
+//     #[crate::test]
 //     async fn test_request_extract() {
 //         let req = TestRequest::with_uri("/name/user1/").to_srv_request();
 //         let (req, mut pl) = req.into_parts();

ntex/src/ws/codec.rs

@@ -1,6 +1,7 @@
-use actix_codec::{Decoder, Encoder};
 use bytes::{Bytes, BytesMut};
 
+use crate::codec::{Decoder, Encoder};
+
 use super::frame::Parser;
 use super::proto::{CloseReason, OpCode};
 use super::ProtocolError;

ntex/src/ws/dispatcher.rs

@@ -2,8 +2,7 @@ use std::future::Future;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-
+use crate::codec::{AsyncRead, AsyncWrite, Framed};
 use crate::framed;
 use crate::service::{IntoService, Service};
 

ntex/tests/connect.rs

@@ -1,9 +1,9 @@
 use std::io;
 
-use actix_codec::{BytesCodec, Framed};
 use bytes::Bytes;
 use futures::SinkExt;
 
+use ntex::codec::{BytesCodec, Framed};
 use ntex::connect::resolver::{ResolverConfig, ResolverOpts};
 use ntex::connect::Connect;
 use ntex::rt::net::TcpStream;

ntex/tests/framed_server.rs

@@ -1,11 +1,11 @@
 use std::cell::Cell;
 use std::rc::Rc;
 
-use actix_codec::BytesCodec;
 use bytes::{Bytes, BytesMut};
 use futures::future::ok;
 
 use ntex::channel::mpsc;
+use ntex::codec::BytesCodec;
 use ntex::framed::{Builder, Connect, FactoryBuilder};
 use ntex::server::test_server;
 use ntex::{fn_factory_with_config, fn_service, IntoService, Service};

ntex/tests/http_awc_client.rs

@@ -105,7 +105,7 @@ async fn test_form() {
 async fn test_timeout() {
     let srv = test::start(|| {
         App::new().service(web::resource("/").route(web::to(|| async {
-            actix_rt::time::delay_for(Duration::from_millis(200)).await;
+            ntex::rt::time::delay_for(Duration::from_millis(200)).await;
             HttpResponse::Ok().body(STR)
         })))
     });
@@ -134,7 +134,7 @@ async fn test_timeout() {
 async fn test_timeout_override() {
     let srv = test::start(|| {
         App::new().service(web::resource("/").route(web::to(|| async {
-            actix_rt::time::delay_for(Duration::from_millis(200)).await;
+            ntex::rt::time::delay_for(Duration::from_millis(200)).await;
             HttpResponse::Ok().body(STR)
         })))
     });
@@ -737,7 +737,7 @@ async fn test_client_cookie_handling() {
 //         }
 //     });
 
-//     let mut sys = actix::System::new("test");
+//     let mut sys = ntex::rt::System::new("test");
 
 //     // client request
 //     let req = client::ClientRequest::get(format!("http://{}/", addr).as_str())

ntex/tests/http_awc_ws.rs

@@ -1,10 +1,10 @@
 use std::io;
 
-use actix_codec::Framed;
 use bytes::Bytes;
 use futures::future::ok;
 use futures::{SinkExt, StreamExt};
 
+use ntex::codec::Framed;
 use ntex::http::test::server as test_server;
 use ntex::http::ws::handshake_response;
 use ntex::http::{body::BodySize, h1, HttpService, Request, Response};

ntex/tests/http_server.rs

@@ -2,7 +2,6 @@ use std::io::{Read, Write};
 use std::time::Duration;
 use std::{io, net, thread};
 
-use actix_rt::time::delay_for;
 use bytes::Bytes;
 use futures::future::{self, err, ok, ready, FutureExt};
 use futures::stream::{once, StreamExt};
@@ -10,6 +9,7 @@ use regex::Regex;
 
 use ntex::http::test::server as test_server;
 use ntex::http::{body, header, HttpService, KeepAlive, Request, Response, StatusCode};
+use ntex::rt::time::delay_for;
 use ntex::service::fn_service;
 use ntex::web::error;
 

ntex/tests/http_ws.rs

@@ -3,13 +3,12 @@ use std::io;
 use std::marker::PhantomData;
 use std::pin::Pin;
 use std::sync::{Arc, Mutex};
+use std::task::{Context, Poll};
 
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
 use bytes::Bytes;
-use futures::future;
-use futures::task::{Context, Poll};
-use futures::{Future, SinkExt, StreamExt};
+use futures::{future, Future, SinkExt, StreamExt};
 
+use ntex::codec::{AsyncRead, AsyncWrite, Framed};
 use ntex::framed::Dispatcher;
 use ntex::http::ws::handshake;
 use ntex::http::{body, h1, test, HttpService, Request, Response};

ntex/tests/server.rs

@@ -3,13 +3,13 @@ use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};
 use std::sync::{mpsc, Arc};
 use std::{net, thread, time};
 
-use actix_codec::{BytesCodec, Framed};
-use actix_rt::net::TcpStream;
 use bytes::Bytes;
 use futures::future::{lazy, ok};
 use futures::SinkExt;
 use net2::TcpBuilder;
 
+use ntex::codec::{BytesCodec, Framed};
+use ntex::rt::net::TcpStream;
 use ntex::server::Server;
 use ntex::service::fn_service;
 
@@ -28,14 +28,14 @@ fn test_bind() {
     let (tx, rx) = mpsc::channel();
 
     let h = thread::spawn(move || {
-        let sys = actix_rt::System::new("test");
+        let sys = ntex::rt::System::new("test");
         let srv = Server::build()
             .workers(1)
             .disable_signals()
             .bind("test", addr, move || fn_service(|_| ok::<_, ()>(())))
             .unwrap()
             .start();
-        let _ = tx.send((srv, actix_rt::System::current()));
+        let _ = tx.send((srv, ntex::rt::System::current()));
         let _ = sys.run();
     });
     let (_, sys) = rx.recv().unwrap();
@@ -52,7 +52,7 @@ fn test_listen() {
     let (tx, rx) = mpsc::channel();
 
     let h = thread::spawn(move || {
-        let sys = actix_rt::System::new("test");
+        let sys = ntex::rt::System::new("test");
         let lst = net::TcpListener::bind(addr).unwrap();
         Server::build()
             .disable_signals()
@@ -60,7 +60,7 @@ fn test_listen() {
             .listen("test", lst, move || fn_service(|_| ok::<_, ()>(())))
             .unwrap()
             .start();
-        let _ = tx.send(actix_rt::System::current());
+        let _ = tx.send(ntex::rt::System::current());
         let _ = sys.run();
     });
     let sys = rx.recv().unwrap();
@@ -78,7 +78,7 @@ fn test_start() {
     let (tx, rx) = mpsc::channel();
 
     let h = thread::spawn(move || {
-        let sys = actix_rt::System::new("test");
+        let sys = ntex::rt::System::new("test");
         let srv: Server = Server::build()
             .backlog(100)
             .disable_signals()
@@ -92,7 +92,7 @@ fn test_start() {
             .unwrap()
             .start();
 
-        let _ = tx.send((srv, actix_rt::System::current()));
+        let _ = tx.send((srv, ntex::rt::System::current()));
         let _ = sys.run();
     });
     let (srv, sys) = rx.recv().unwrap();
@@ -144,7 +144,7 @@ fn test_configure() {
 
     let h = thread::spawn(move || {
         let num = num2.clone();
-        let sys = actix_rt::System::new("test");
+        let sys = ntex::rt::System::new("test");
         let srv = Server::build()
             .disable_signals()
             .configure(move |cfg| {
@@ -167,7 +167,7 @@ fn test_configure() {
             .unwrap()
             .workers(1)
             .start();
-        let _ = tx.send((srv, actix_rt::System::current()));
+        let _ = tx.send((srv, ntex::rt::System::current()));
         let _ = sys.run();
     });
     let (_, sys) = rx.recv().unwrap();

ntex/tests/web_httpserver.rs

@@ -23,7 +23,7 @@ async fn test_start() {
     let (tx, rx) = mpsc::channel();
 
     thread::spawn(move || {
-        let sys = actix_rt::System::new("test");
+        let sys = ntex::rt::System::new("test");
 
         let srv = HttpServer::new(|| {
             App::new().service(
@@ -45,27 +45,24 @@ async fn test_start() {
         .unwrap()
         .run();
 
-        let _ = tx.send((srv, actix_rt::System::current()));
+        let _ = tx.send((srv, ntex::rt::System::current()));
         let _ = sys.run();
     });
     let (srv, sys) = rx.recv().unwrap();
 
-    #[cfg(feature = "client")]
-    {
-        use actix_http::client;
+    use ntex::http::client;
 
-        let client = awc::Client::build()
-            .connector(
-                client::Connector::new()
-                    .timeout(Duration::from_millis(100))
-                    .finish(),
-            )
-            .finish();
+    let client = client::Client::build()
+        .connector(
+            client::Connector::new()
+                .timeout(Duration::from_millis(100))
+                .finish(),
+        )
+        .finish();
 
-        let host = format!("http://{}", addr);
-        let response = client.get(host.clone()).send().await.unwrap();
-        assert!(response.status().is_success());
-    }
+    let host = format!("http://{}", addr);
+    let response = client.get(host.clone()).send().await.unwrap();
+    assert!(response.status().is_success());
 
     // stop
     let _ = srv.stop(false);
@@ -97,7 +94,7 @@ async fn test_start_ssl() {
     let (tx, rx) = mpsc::channel();
 
     thread::spawn(move || {
-        let sys = actix_rt::System::new("test");
+        let sys = ntex::rt::System::new("test");
         let builder = ssl_acceptor().unwrap();
 
         let srv = HttpServer::new(|| {
@@ -116,7 +113,7 @@ async fn test_start_ssl() {
         .unwrap()
         .run();
 
-        let _ = tx.send((srv, actix_rt::System::current()));
+        let _ = tx.send((srv, ntex::rt::System::current()));
         let _ = sys.run();
     });
     let (srv, sys) = rx.recv().unwrap();

ntex/tests/web_server.rs

@@ -47,7 +47,7 @@ const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
 struct TestBody {
     data: Bytes,
     chunk_size: usize,
-    delay: actix_rt::time::Delay,
+    delay: ntex::rt::time::Delay,
 }
 
 impl TestBody {
@@ -55,7 +55,7 @@ impl TestBody {
         TestBody {
             data,
             chunk_size,
-            delay: actix_rt::time::delay_for(std::time::Duration::from_millis(10)),
+            delay: ntex::rt::time::delay_for(std::time::Duration::from_millis(10)),
         }
     }
 }
@@ -69,7 +69,7 @@ impl futures::Stream for TestBody {
     ) -> Poll<Option<Self::Item>> {
         ready!(Pin::new(&mut self.delay).poll(cx));
 
-        self.delay = actix_rt::time::delay_for(std::time::Duration::from_millis(10));
+        self.delay = ntex::rt::time::delay_for(std::time::Duration::from_millis(10));
         let chunk_size = std::cmp::min(self.chunk_size, self.data.len());
         let chunk = self.data.split_to(chunk_size);
         if chunk.is_empty() {
@@ -793,7 +793,7 @@ async fn test_reading_deflate_encoding_large_random_rustls() {
 
 // #[test]
 // fn test_server_cookies() {
-//     use actix_web::http;
+//     use ntex::http;
 
 //     let srv = test::TestServer::with_factory(|| {
 //         App::new().resource("/", |r| {