Improve tests coverage (#161)

* improve tests coverage
* update base64 crate

.github/workflows/cov.yml

@@ -26,10 +26,7 @@ jobs:
         run: cargo llvm-cov clean --workspace
 
       - name: Code coverage (glommio)
-        run: cargo llvm-cov --no-report --all --no-default-features --features="glommio,cookie,url,compress,openssl,rustls"
-
-      - name: Code coverage (async-std)
-        run: cargo llvm-cov --no-report --all --no-default-features --features="async-std,cookie,url,compress,openssl,rustls"
+        run: cargo +nightly llvm-cov --no-report --all --no-default-features --features="glommio,cookie,url,compress,openssl,rustls"
 
       - name: Code coverage
         run: cargo +nightly llvm-cov --no-report --all --doctests --no-default-features --features="tokio,cookie,url,compress,openssl,rustls"

ntex-bytes/Cargo.toml

@@ -27,4 +27,4 @@ simdutf8 = { version = "0.1.4", optional = true }
 [dev-dependencies]
 serde_test = "1.0"
 serde_json = "1.0"
-ntex = { version = "0.6.0-alpha.0", features = ["tokio"] }
+ntex = { version = "0.6.0", features = ["tokio"] }

ntex-bytes/src/bytes.rs

@@ -541,6 +541,8 @@ impl Bytes {
     /// let b = a.slice(2..5);
     ///
     /// assert_eq!(&b[..], b"llo");
+    /// assert_eq!(&b[..=1], b"ll");
+    /// assert_eq!(&b[1..=1], b"l");
     /// ```
     ///
     /// # Panics
@@ -4047,7 +4049,7 @@ fn abort() {
 
 #[cfg(test)]
 mod tests {
-    use std::convert::TryFrom;
+    use std::{collections::HashMap, convert::TryFrom};
 
     use super::*;
 
@@ -4087,28 +4089,33 @@ mod tests {
 
         let mut b: Bytes = BytesMut::try_from(b).unwrap().freeze();
         assert_eq!(b, LONG);
-        assert_eq!(Buf::remaining(&b), LONG.len());
-        assert_eq!(Buf::chunk(&b), LONG);
-        Buf::advance(&mut b, 10);
+        assert!(!(b > b));
+        assert_eq!(<Bytes as Buf>::remaining(&b), LONG.len());
+        assert_eq!(<Bytes as Buf>::chunk(&b), LONG);
+        <Bytes as Buf>::advance(&mut b, 10);
         assert_eq!(Buf::chunk(&b), &LONG[10..]);
 
+        let mut h: HashMap<Bytes, usize> = HashMap::default();
+        h.insert(b.clone(), 1);
+        assert_eq!(h.get(&b), Some(&1));
+
         let mut b = BytesMut::try_from(LONG).unwrap();
         assert_eq!(b, LONG);
-        assert_eq!(Buf::remaining(&b), LONG.len());
-        assert_eq!(BufMut::remaining_mut(&b), 25);
-        assert_eq!(Buf::chunk(&b), LONG);
-        Buf::advance(&mut b, 10);
-        assert_eq!(Buf::chunk(&b), &LONG[10..]);
+        assert_eq!(<BytesMut as Buf>::remaining(&b), LONG.len());
+        assert_eq!(<BytesMut as BufMut>::remaining_mut(&b), 25);
+        assert_eq!(<BytesMut as Buf>::chunk(&b), LONG);
+        <BytesMut as Buf>::advance(&mut b, 10);
+        assert_eq!(<BytesMut as Buf>::chunk(&b), &LONG[10..]);
 
         let mut b = BytesMut::with_capacity(12);
-        BufMut::put_i8(&mut b, 1);
+        <BytesMut as BufMut>::put_i8(&mut b, 1);
         assert_eq!(b, b"\x01".as_ref());
-        BufMut::put_u8(&mut b, 2);
+        <BytesMut as BufMut>::put_u8(&mut b, 2);
         assert_eq!(b, b"\x01\x02".as_ref());
-        BufMut::put_slice(&mut b, b"12345");
+        <BytesMut as BufMut>::put_slice(&mut b, b"12345");
         assert_eq!(b, b"\x01\x0212345".as_ref());
-        BufMut::chunk_mut(&mut b).write_byte(0, b'1');
-        unsafe { BufMut::advance_mut(&mut b, 1) };
+        <BytesMut as BufMut>::chunk_mut(&mut b).write_byte(0, b'1');
+        unsafe { <BytesMut as BufMut>::advance_mut(&mut b, 1) };
         assert_eq!(b, b"\x01\x02123451".as_ref());
     }
 

ntex-bytes/tests/test_bytes.rs

@@ -1064,7 +1064,14 @@ async fn pool_usage() {
 
     let p_ref = PoolId::P1.set_pool_size(10 * 1024);
     let p1 = p_ref.pool();
-    let p2 = p_ref.pool();
+    let p2 = p_ref.pool().clone();
+
+    let p_ref2 = PoolRef::from(&p1);
+    assert_eq!(p_ref2.read_params_high(), 4096);
+    assert_eq!(p_ref2.write_params_high(), 4096);
+    p_ref2.id().set_spawn_fn(|f| {
+        let _ = ntex::rt::spawn(f);
+    });
 
     assert_eq!(Poll::Ready(()), util::lazy(|cx| p1.poll_ready(cx)).await);
 

ntex-connect/src/message.rs

@@ -271,10 +271,14 @@ mod tests {
         assert_eq!(*connect.get_ref(), "www.rust-lang.org");
         connect = connect.set_port(80);
         assert_eq!(connect.port(), 80);
+        let addrs = connect.addrs().clone();
+        assert_eq!(format!("{:?}", addrs), "[]");
         assert!(connect.addrs().next().is_none());
 
         let addr: SocketAddr = "127.0.0.1:8080".parse().unwrap();
         connect = connect.set_addrs(vec![addr]);
+        let addrs = connect.addrs().clone();
+        assert_eq!(format!("{:?}", addrs), "[127.0.0.1:8080]");
         let addrs: Vec<_> = connect.take_addrs().collect();
         assert_eq!(addrs.len(), 1);
         assert!(addrs.contains(&addr));

ntex-http/src/map.rs

@@ -599,6 +599,7 @@ mod tests {
             *m.get_mut(CONTENT_TYPE).unwrap(),
             HeaderValue::from_static("text")
         );
+        assert!(format!("{:?}", m).contains("HeaderMap"));
 
         assert!(m.keys().any(|x| x == CONTENT_TYPE));
         m.remove("content-type");
@@ -610,9 +611,13 @@ mod tests {
         let mut map = HeaderMap::new();
 
         map.append(ACCEPT_ENCODING, HeaderValue::from_static("gzip"));
+        assert_eq!(
+            map.get_all(ACCEPT_ENCODING).collect::<Vec<_>>(),
+            vec![&HeaderValue::from_static("gzip"),]
+        );
+
         map.append(ACCEPT_ENCODING, HeaderValue::from_static("br"));
         map.append(ACCEPT_ENCODING, HeaderValue::from_static("deflate"));
-
         assert_eq!(
             map.get_all(ACCEPT_ENCODING).collect::<Vec<_>>(),
             vec![
@@ -621,5 +626,28 @@ mod tests {
                 &HeaderValue::from_static("deflate"),
             ]
         );
+        assert_eq!(
+            map.get(ACCEPT_ENCODING),
+            Some(&HeaderValue::from_static("gzip"))
+        );
+        assert_eq!(
+            map.get_mut(ACCEPT_ENCODING),
+            Some(&mut HeaderValue::from_static("gzip"))
+        );
+
+        map.remove(ACCEPT_ENCODING);
+        assert_eq!(map.get(ACCEPT_ENCODING), None);
+    }
+
+    #[test]
+    fn test_from_http() {
+        let mut map = http::HeaderMap::new();
+        map.append(ACCEPT_ENCODING, http::HeaderValue::from_static("gzip"));
+
+        let map2 = HeaderMap::from(map);
+        assert_eq!(
+            map2.get(ACCEPT_ENCODING),
+            Some(&HeaderValue::from_static("gzip"))
+        );
     }
 }

ntex-http/src/value.rs

@@ -792,8 +792,14 @@ mod tests {
         assert!(&hdr < "upgrade2");
         assert!(hdr < "upgrade2");
         assert!(hdr < "upgrade2".to_string());
+        assert!(hdr < &b"upgrade2"[..]);
+        assert!(hdr < b"upgrade2"[..]);
+        assert!(hdr != &b"upgrade2"[..]);
+        assert!(hdr != b"upgrade2"[..]);
         assert!("upgrade2" > hdr);
         assert!("upgrade2".to_string() > hdr);
+        assert!(b"upgrade2"[..] > hdr);
+        assert!("upgrade2"[..] != hdr);
     }
 
     #[test]

ntex-io/src/ioref.rs

@@ -263,6 +263,9 @@ mod tests {
         let state = Io::new(server);
         let msg = state.recv(&BytesCodec).await.unwrap().unwrap();
         assert_eq!(msg, Bytes::from_static(BIN));
+        assert_eq!(state.get_ref(), state.as_ref().clone());
+        assert_eq!(format!("{:?}", state), "Io { open: true }");
+        assert_eq!(format!("{:?}", state.get_ref()), "IoRef { open: true }");
 
         let res = poll_fn(|cx| Poll::Ready(state.poll_recv(&BytesCodec, cx))).await;
         assert!(res.is_pending());
@@ -293,10 +296,7 @@ mod tests {
         let (client, server) = IoTest::create();
         client.remote_buffer_cap(1024);
         let state = Io::new(server);
-        state
-            .send(Bytes::from_static(b"test"), &BytesCodec)
-            .await
-            .unwrap();
+        state.write(b"test").unwrap();
         let buf = client.read().await.unwrap();
         assert_eq!(buf, Bytes::from_static(b"test"));
 
@@ -379,14 +379,6 @@ mod tests {
         write_order: Rc<RefCell<Vec<usize>>>,
     }
     impl<F: Filter> Filter for Counter<F> {
-        fn poll_shutdown(&self) -> Poll<io::Result<()>> {
-            Poll::Ready(Ok(()))
-        }
-
-        fn query(&self, _: std::any::TypeId) -> Option<Box<dyn std::any::Any>> {
-            None
-        }
-
         fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<ReadStatus> {
             self.inner.poll_read_ready(cx)
         }

ntex-io/src/lib.rs

@@ -50,7 +50,9 @@ pub enum WriteStatus {
 }
 
 pub trait Filter: 'static {
-    fn query(&self, id: TypeId) -> Option<Box<dyn Any>>;
+    fn query(&self, _: TypeId) -> Option<Box<dyn Any>> {
+        None
+    }
 
     fn get_read_buf(&self) -> Option<BytesVec>;
 
@@ -72,7 +74,9 @@ pub trait Filter: 'static {
     fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<WriteStatus>;
 
     /// Gracefully shutdown filter
-    fn poll_shutdown(&self) -> Poll<sio::Result<()>>;
+    fn poll_shutdown(&self) -> Poll<sio::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
 }
 
 /// Creates new `Filter` values.

ntex-router/src/de.rs

@@ -587,6 +587,16 @@ mod tests {
         assert_eq!(s.0, "name");
         assert_eq!(s.1, 32);
 
+        let s: (&str, ()) =
+            de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(s.0, "name");
+        assert_eq!(s.1, ());
+
+        let s: (&str, Option<u8>) =
+            de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(s.0, "name");
+        assert_eq!(s.1, Some(32));
+
         let res: Vec<String> =
             de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
         assert_eq!(res[0], "name".to_owned());

ntex-rt/src/lib.rs

@@ -153,6 +153,7 @@ mod tokio {
     pub fn block_on<F: Future<Output = ()>>(fut: F) {
         let rt = tok_io::runtime::Builder::new_current_thread()
             .enable_all()
+            // .unhandled_panic(tok_io::runtime::UnhandledPanic::ShutdownRuntime)
             .build()
             .unwrap();
         tok_io::task::LocalSet::new().block_on(&rt, fut);

ntex-util/src/services/extensions.rs

@@ -70,10 +70,19 @@ impl Extensions {
 
 impl fmt::Debug for Extensions {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Extensions").finish()
+        f.debug_struct("Extensions")
+            .field("size", &self.map.len())
+            .finish()
     }
 }
 
+#[test]
+fn test_debug() {
+    let mut map = Extensions::new();
+    map.insert::<i8>(123);
+    assert_eq!(format!("{:?}", map), "Extensions { size: 1 }");
+}
+
 #[test]
 fn test_remove() {
     let mut map = Extensions::new();

ntex-util/src/services/inflight.rs

@@ -9,6 +9,7 @@ use super::counter::{Counter, CounterGuard};
 /// async requests.
 ///
 /// Default number of in-flight requests is 15
+#[derive(Copy, Clone, Debug)]
 pub struct InFlight {
     max_inflight: usize,
 }
@@ -131,7 +132,7 @@ mod tests {
     }
 
     #[ntex_macros::rt_test2]
-    async fn test_transform() {
+    async fn test_inflight() {
         let wait_time = Duration::from_millis(50);
 
         let srv = InFlightService::new(1, SleepService(wait_time));
@@ -146,9 +147,14 @@ mod tests {
     }
 
     #[ntex_macros::rt_test2]
-    async fn test_newtransform() {
-        let wait_time = Duration::from_millis(50);
+    async fn test_middleware() {
+        assert_eq!(InFlight::default().max_inflight, 15);
+        assert_eq!(
+            format!("{:?}", InFlight::new(1)),
+            "InFlight { max_inflight: 1 }"
+        );
 
+        let wait_time = Duration::from_millis(50);
         let srv = apply(
             InFlight::new(1),
             fn_factory(|| async { Ok::<_, ()>(SleepService(wait_time)) }),

ntex-util/src/time/mod.rs

@@ -183,7 +183,7 @@ impl Deadline {
     /// Returns `true` if `Deadline` has elapsed.
     #[inline]
     pub fn is_elapsed(&self) -> bool {
-        self.hnd.as_ref().map(|t| t.is_elapsed()).unwrap_or(false)
+        self.hnd.as_ref().map(|t| t.is_elapsed()).unwrap_or(true)
     }
 
     #[inline]
@@ -439,6 +439,13 @@ mod tests {
         let mut dl = deadline(Millis(1));
         dl.reset(Millis::ZERO);
         assert!(lazy(|cx| dl.poll_elapsed(cx)).await.is_pending());
+
+        let mut dl = deadline(Millis(0));
+        assert!(dl.is_elapsed());
+        dl.reset(Millis(1));
+        assert!(lazy(|cx| dl.poll_elapsed(cx)).await.is_pending());
+
+        assert!(format!("{:?}", dl).contains("Deadline"));
     }
 
     #[ntex_macros::rt_test2]

ntex-util/src/time/types.rs

@@ -244,5 +244,8 @@ mod tests {
 
         let s = Seconds::new(10) + Seconds::new(10);
         assert_eq!(s.seconds(), 20);
+
+        assert_eq!(Seconds(0).map(|_| 1usize), None);
+        assert_eq!(Seconds(2).map(|_| 1usize), Some(1));
     }
 }

ntex/Cargo.toml

@@ -66,7 +66,7 @@ ntex-async-std = { version = "0.2.0", optional = true }
 
 async-oneshot = "0.5.0"
 async-channel = "1.8.0"
-base64 = "0.20"
+base64 = "0.21"
 bitflags = "1.3"
 log = "0.4"
 num_cpus = "1.13"

ntex/src/http/client/builder.rs

@@ -1,5 +1,7 @@
 use std::{convert::TryFrom, fmt, rc::Rc};
 
+use base64::{engine::general_purpose::STANDARD as base64, Engine};
+
 use crate::http::error::HttpError;
 use crate::http::header::{self, HeaderMap, HeaderName, HeaderValue};
 use crate::{service::Service, time::Millis};
@@ -118,7 +120,7 @@ impl ClientBuilder {
         };
         self.header(
             header::AUTHORIZATION,
-            format!("Basic {}", base64::encode(auth)),
+            format!("Basic {}", base64.encode(auth)),
         )
     }
 

ntex/src/http/client/request.rs

@@ -1,5 +1,6 @@
 use std::{convert::TryFrom, error::Error, fmt, net, rc::Rc};
 
+use base64::{engine::general_purpose::STANDARD as base64, Engine};
 #[cfg(feature = "cookie")]
 use coo_kie::{Cookie, CookieJar};
 use serde::Serialize;
@@ -255,7 +256,7 @@ impl ClientRequest {
         };
         self.header(
             header::AUTHORIZATION,
-            format!("Basic {}", base64::encode(auth)),
+            format!("Basic {}", base64.encode(auth)),
         )
     }
 

ntex/src/ws/client.rs

@@ -8,6 +8,7 @@ use crate::connect::rustls;
 #[cfg(feature = "cookie")]
 use coo_kie::{Cookie, CookieJar};
 
+use base64::{engine::general_purpose::STANDARD as base64, Engine};
 use nanorand::{Rng, WyRand};
 
 use crate::connect::{Connect, ConnectError, Connector};
@@ -112,7 +113,7 @@ impl<F, T> WsClient<F, T> {
             Some(password) => format!("{}:{}", username, password),
             None => format!("{}:", username),
         };
-        self.set_header(AUTHORIZATION, format!("Basic {}", base64::encode(auth)))
+        self.set_header(AUTHORIZATION, format!("Basic {}", base64.encode(auth)))
     }
 
     /// Set HTTP bearer authentication header
@@ -147,7 +148,7 @@ where
         // when decoded, is 16 bytes in length (RFC 6455)
         let mut sec_key: [u8; 16] = [0; 16];
         WyRand::new().fill(&mut sec_key);
-        let key = base64::encode(sec_key);
+        let key = base64.encode(sec_key);
 
         headers.insert(
             header::SEC_WEBSOCKET_KEY,
@@ -460,7 +461,7 @@ where
             Some(password) => format!("{}:{}", username, password),
             None => format!("{}:", username),
         };
-        self.header(AUTHORIZATION, format!("Basic {}", base64::encode(auth)))
+        self.header(AUTHORIZATION, format!("Basic {}", base64.encode(auth)))
     }
 
     /// Set HTTP bearer authentication header

ntex/src/ws/proto.rs

@@ -1,6 +1,7 @@
-use std::convert::{From, Into};
 use std::fmt;
 
+use base64::{engine::general_purpose::STANDARD as base64, Engine};
+
 use self::OpCode::*;
 /// Operation codes as part of rfc6455.
 #[derive(Debug, Eq, PartialEq, Clone, Copy)]
@@ -211,7 +212,7 @@ pub fn hash_key(key: &[u8]) -> String {
     hasher.update(key);
     hasher.update(WS_GUID.as_bytes());
 
-    base64::encode(&hasher.finalize()[..])
+    base64.encode(&hasher.finalize()[..])
 }
 
 #[cfg(test)]

ntex/tests/connect.rs

@@ -1,4 +1,4 @@
-use std::{io, sync::Arc};
+use std::{io, rc::Rc, sync::Arc};
 
 use ntex::codec::BytesCodec;
 use ntex::connect::Connect;
@@ -129,7 +129,7 @@ async fn test_openssl_read_before_error() {
         }))
         .and_then(openssl::Acceptor::new(ssl_acceptor()))
         .and_then(fn_service(|io: Io<_>| async move {
-            io.send(Bytes::from_static(b"test"), &BytesCodec)
+            io.send(Bytes::from_static(b"test"), &Rc::new(BytesCodec))
                 .await
                 .unwrap();
             time::sleep(time::Millis(100)).await;
@@ -143,7 +143,7 @@ async fn test_openssl_read_before_error() {
     let conn = ntex::connect::openssl::Connector::new(builder.build());
     let addr = format!("127.0.0.1:{}", srv.addr().port());
     let io = conn.call(addr.into()).await.unwrap();
-    let item = io.recv(&BytesCodec).await.unwrap().unwrap();
+    let item = io.recv(&Rc::new(BytesCodec)).await.unwrap().unwrap();
     assert_eq!(item, Bytes::from_static(b"test"));
 
     io.send(Bytes::from_static(b"test"), &BytesCodec)