Merge pull request #64 from seanmonstar/tests-ergo-frames

add ergonomics to testing with frames

tests/support/src/frames.rs

@@ -0,0 +1,159 @@
+use std::fmt;
+
+use bytes::{Bytes, IntoBuf};
+use http::{self, HeaderMap, HttpTryFrom};
+
+use h2::frame::{self, Frame, StreamId};
+use super::SendFrame;
+
+pub const SETTINGS: &'static [u8] = &[0, 0, 0, 4, 0, 0, 0, 0, 0];
+pub const SETTINGS_ACK: &'static [u8] = &[0, 0, 0, 4, 1, 0, 0, 0, 0];
+
+// ==== helper functions to easily construct h2 Frames ====
+
+pub fn headers<T>(id: T) -> MockHeaders
+    where T: Into<StreamId>,
+{
+    MockHeaders(frame::Headers::new(
+        id.into(),
+        frame::Pseudo::default(),
+        HeaderMap::default(),
+    ))
+}
+
+pub fn data<T, B>(id: T, buf: B) -> MockData
+    where T: Into<StreamId>,
+          B: Into<Bytes>,
+{
+    MockData(frame::Data::new(id.into(), buf.into()))
+}
+
+pub fn window_update<T>(id: T, sz: u32) -> frame::WindowUpdate
+    where T: Into<StreamId>,
+{
+    frame::WindowUpdate::new(id.into(), sz)
+}
+
+// Headers helpers
+
+pub struct MockHeaders(frame::Headers);
+
+impl MockHeaders {
+    pub fn request<M, U>(self, method: M, uri: U) -> Self
+        where M: HttpTryInto<http::Method>,
+              U: HttpTryInto<http::Uri>,
+    {
+        let method = method.try_into().unwrap();
+        let uri = uri.try_into().unwrap();
+        let (id, _, fields) = self.into_parts();
+        let frame = frame::Headers::new(
+            id,
+            frame::Pseudo::request(method, uri),
+            fields
+        );
+        MockHeaders(frame)
+    }
+
+    pub fn response<S>(self, status: S) -> Self
+        where S: HttpTryInto<http::StatusCode>,
+    {
+        let status = status.try_into().unwrap();
+        let (id, _, fields) = self.into_parts();
+        let frame = frame::Headers::new(
+            id,
+            frame::Pseudo::response(status),
+            fields
+        );
+        MockHeaders(frame)
+    }
+
+    pub fn fields(self, fields: HeaderMap) -> Self {
+        let (id, pseudo, _) = self.into_parts();
+        let frame = frame::Headers::new(id, pseudo, fields);
+        MockHeaders(frame)
+    }
+
+    pub fn eos(mut self) -> Self {
+        self.0.set_end_stream();
+        self
+    }
+
+    fn into_parts(self) -> (StreamId, frame::Pseudo, HeaderMap) {
+        assert!(!self.0.is_end_stream(), "eos flag will be lost");
+        assert!(self.0.is_end_headers(), "unset eoh will be lost");
+        let id = self.0.stream_id();
+        let parts = self.0.into_parts();
+        (id, parts.0, parts.1)
+    }
+}
+
+impl fmt::Debug for MockHeaders {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt(&self.0, f)
+    }
+}
+
+impl From<MockHeaders> for Frame {
+    fn from(src: MockHeaders) -> Self {
+        Frame::Headers(src.0)
+    }
+}
+
+impl From<MockHeaders> for SendFrame {
+    fn from(src: MockHeaders) -> Self {
+        Frame::Headers(src.0)
+    }
+}
+
+// Data helpers
+
+pub struct MockData(frame::Data);
+
+impl MockData {
+    pub fn eos(mut self) -> Self {
+        self.0.set_end_stream(true);
+        self
+    }
+}
+
+impl fmt::Debug for MockData {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt(&self.0, f)
+    }
+}
+
+impl From<MockData> for Frame {
+    fn from(src: MockData) -> Self {
+        Frame::Data(src.0)
+    }
+}
+
+impl From<MockData> for SendFrame {
+    fn from(src: MockData) -> Self {
+        let id = src.0.stream_id();
+        let eos = src.0.is_end_stream();
+        let payload = src.0.into_payload();
+        let mut frame = frame::Data::new(id, payload.into_buf());
+        frame.set_end_stream(eos);
+        Frame::Data(frame)
+    }
+}
+
+// ==== "trait alias" for types that are HttpTryFrom and have Debug Errors ====
+
+pub trait HttpTryInto<T> {
+    type Error: fmt::Debug;
+
+    fn try_into(self) -> Result<T, Self::Error>;
+}
+
+impl<T, U> HttpTryInto<T> for U
+    where T: HttpTryFrom<U>,
+          T::Error: fmt::Debug,
+{
+    type Error = T::Error;
+
+    fn try_into(self) -> Result<T, Self::Error> {
+        T::try_from(self)
+    }
+}

tests/support/src/lib.rs

@@ -16,6 +16,7 @@ mod assert;
 #[macro_use]
 pub mod raw;
 
+pub mod frames;
 pub mod prelude;
 pub mod mock;
 

tests/support/src/mock.rs

@@ -3,13 +3,13 @@ use {FutureExt, SendFrame};
 use h2::{self, SendError, RecvError};
 use h2::frame::{self, Frame};
 
-use futures::{Future, Stream, Poll};
+use futures::{Async, Future, Stream, Poll};
 use futures::task::{self, Task};
 
 use tokio_io::{AsyncRead, AsyncWrite};
 use tokio_io::io::read_exact;
 
-use std::{cmp, io};
+use std::{cmp, fmt, io};
 use std::io::ErrorKind::WouldBlock;
 use std::sync::{Arc, Mutex};
 
@@ -303,3 +303,118 @@ impl AsyncWrite for Pipe {
         Ok(().into())
     }
 }
+
+pub trait HandleFutureExt {
+    fn recv_settings(self) -> RecvFrame<Box<Future<Item=(Option<Frame>, Handle), Error=()>>>
+        where Self: Sized + 'static,
+              Self: Future<Item=(frame::Settings, Handle)>,
+              Self::Error: fmt::Debug,
+    {
+        let map = self.map(|(settings, handle)| (Some(settings.into()), handle)).unwrap();
+
+        let boxed: Box<Future<Item=(Option<Frame>, Handle), Error=()>> = Box::new(map);
+        RecvFrame {
+            inner: boxed,
+            frame: frame::Settings::default().into(),
+        }
+    }
+
+    fn recv_frame<T>(self, frame: T) -> RecvFrame<<Self as IntoRecvFrame>::Future>
+        where Self: IntoRecvFrame + Sized,
+              T: Into<Frame>,
+    {
+        self.into_recv_frame(frame.into())
+    }
+
+    fn send_frame<T>(self, frame: T) -> SendFrameFut<Self>
+        where Self: Sized,
+              T: Into<SendFrame>,
+    {
+        SendFrameFut {
+            inner: self,
+            frame: Some(frame.into()),
+        }
+    }
+}
+
+pub struct RecvFrame<T> {
+    inner: T,
+    frame: Frame,
+}
+
+impl<T> Future for RecvFrame<T>
+    where T: Future<Item=(Option<Frame>, Handle)>,
+          T::Error: fmt::Debug,
+{
+    type Item = Handle;
+    type Error = ();
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        let (frame, handle) = match self.inner.poll().unwrap() {
+            Async::Ready((frame, handle)) => (frame, handle),
+            Async::NotReady => return Ok(Async::NotReady),
+        };
+        assert_eq!(frame.unwrap(), self.frame);
+        Ok(Async::Ready(handle))
+    }
+}
+
+pub struct SendFrameFut<T> {
+    inner: T,
+    frame: Option<SendFrame>,
+}
+
+impl<T> Future for SendFrameFut<T>
+    where T: Future<Item=Handle>,
+          T::Error: fmt::Debug,
+{
+    type Item = Handle;
+    type Error = ();
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        let mut handle = match self.inner.poll().unwrap() {
+            Async::Ready(handle) => handle,
+            Async::NotReady => return Ok(Async::NotReady),
+        };
+        handle.send(self.frame.take().unwrap()).unwrap();
+        Ok(Async::Ready(handle))
+    }
+}
+
+impl<T> HandleFutureExt for T
+    where T: Future + 'static,
+{
+}
+
+pub trait IntoRecvFrame {
+    type Future: Future;
+    fn into_recv_frame(self, frame: Frame) -> RecvFrame<Self::Future>;
+}
+
+impl IntoRecvFrame for Handle {
+    type Future = ::futures::stream::StreamFuture<Self>;
+
+    fn into_recv_frame(self, frame: Frame) -> RecvFrame<Self::Future> {
+        RecvFrame {
+            inner: self.into_future(),
+            frame: frame,
+        }
+    }
+}
+
+impl<T> IntoRecvFrame for T
+    where T: Future<Item=Handle> + 'static,
+          T::Error: fmt::Debug,
+{
+    type Future = Box<Future<Item=(Option<Frame>, Handle), Error=()>>;
+
+    fn into_recv_frame(self, frame: Frame) -> RecvFrame<Self::Future> {
+        let into_fut = Box::new(self.unwrap()
+            .and_then(|handle| handle.into_future().unwrap())
+        );
+        RecvFrame {
+            inner: into_fut,
+            frame: frame,
+        }
+    }
+}

tests/support/src/prelude.rs

@@ -8,7 +8,10 @@ pub use self::h2::client::{self, Client};
 pub use self::h2::server::{self, Server};
 
 // Re-export mock
-pub use super::mock;
+pub use super::mock::{self, HandleFutureExt};
+
+// Re-export frames helpers
+pub use super::frames;
 
 // Re-export some type defines
 pub use super::{Codec, SendFrame};
@@ -100,9 +103,3 @@ impl<T, B> ClientExt for Client<T, B>
     }
 }
 
-pub mod frames {
-    //! Some useful frames
-
-    pub const SETTINGS: &'static [u8] = &[0, 0, 0, 4, 0, 0, 0, 0, 0];
-    pub const SETTINGS_ACK: &'static [u8] = &[0, 0, 0, 4, 1, 0, 0, 0, 0];
-}