Initial Dever 0.0.1

test/rust/runtime/http/transport/mod.rs

@@ -0,0 +1,60 @@
+use super::Transport;
+use std::{io, time::Duration};
+use tokio::io::{AsyncReadExt, AsyncWrite, AsyncWriteExt};
+
+#[test]
+fn vectored_write_preserves_parts_and_stall_timeout() {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_time()
+        .build()
+        .unwrap()
+        .block_on(async {
+            let (writer, mut reader) = tokio::io::duplex(8);
+            let mut transport = Transport::new(writer, Duration::from_millis(10));
+            assert!(transport.is_write_vectored());
+            let parts = [io::IoSlice::new(b"head"), io::IoSlice::new(b"body")];
+            assert_eq!(transport.write_vectored(&parts).await.unwrap(), 8);
+            let error =
+                tokio::time::timeout(Duration::from_secs(1), transport.write_vectored(&parts))
+                    .await
+                    .unwrap()
+                    .unwrap_err();
+            assert_eq!(error.kind(), io::ErrorKind::TimedOut);
+            let mut received = [0; 8];
+            reader.read_exact(&mut received).await.unwrap();
+            assert_eq!(&received, b"headbody");
+        });
+}
+
+#[test]
+fn vectored_write_preserves_partial_progress_and_large_bodies() {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_time()
+        .build()
+        .unwrap()
+        .block_on(async {
+            for length in [0, 1, 31, 4095, 4096, 4097, 65536] {
+                let (writer, mut reader) = tokio::io::duplex(17);
+                let mut transport = Transport::new(writer, Duration::from_secs(2));
+                let header = b"header";
+                let body: Vec<u8> = (0..length).map(|index| (index % 251) as u8).collect();
+                let expected = [header.as_slice(), body.as_slice()].concat();
+                let send = async {
+                    let mut parts = [io::IoSlice::new(header), io::IoSlice::new(&body)];
+                    let mut remaining = &mut parts[..];
+                    while !remaining.is_empty() {
+                        let count = transport.write_vectored(remaining).await.unwrap();
+                        assert!(count > 0);
+                        io::IoSlice::advance_slices(&mut remaining, count);
+                    }
+                    transport.shutdown().await.unwrap();
+                };
+                let receive = async {
+                    let mut received = Vec::new();
+                    reader.read_to_end(&mut received).await.unwrap();
+                    assert_eq!(received, expected);
+                };
+                tokio::join!(send, receive);
+            }
+        });
+}

test/rust/runtime/http/transport/pool.rs

@@ -0,0 +1,61 @@
+use super::*;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+#[test]
+fn pooled_socket_preserves_vectored_writes_and_idle_expiry() {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .unwrap()
+        .block_on(async {
+            let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+            let origin = Arc::new(
+                Origin::parse(&format!("http://{}", listener.local_addr().unwrap())).unwrap(),
+            );
+            let limits = crate::http::Limits {
+                timeout_ms: 100,
+                ..Default::default()
+            }
+            .check()
+            .unwrap();
+            let mut connector = Connector::new(
+                origin.clone(),
+                &crate::tls::system(),
+                &limits,
+                Duration::from_millis(100),
+            );
+            let mut socket = connector
+                .call(origin.uri.clone())
+                .await
+                .unwrap()
+                .into_inner();
+            let (mut peer, _) = listener.accept().await.unwrap();
+            assert!(socket.is_write_vectored());
+            let body = vec![7; 65536];
+            let send = async {
+                let mut parts = [io::IoSlice::new(b"head"), io::IoSlice::new(&body)];
+                let mut remaining = &mut parts[..];
+                while !remaining.is_empty() {
+                    let count = socket.write_vectored(remaining).await.unwrap();
+                    assert_ne!(count, 0);
+                    io::IoSlice::advance_slices(&mut remaining, count);
+                }
+            };
+            let receive = async {
+                let mut received = vec![0; 4 + body.len()];
+                peer.read_exact(&mut received).await.unwrap();
+                assert_eq!(&received[..4], b"head");
+                assert_eq!(&received[4..], body);
+            };
+            tokio::join!(send, receive);
+            tokio::time::sleep(Duration::from_millis(150)).await;
+            assert_eq!(
+                socket
+                    .write_vectored(&[io::IoSlice::new(b"expired")])
+                    .await
+                    .unwrap_err()
+                    .kind(),
+                io::ErrorKind::TimedOut
+            );
+        });
+}