Add test infrastructure to work directly with frames (#56)

This adds a `Codec` based testing API. This is a bit less annoying than writing
at the raw H2 wire protocol level...

tests/support/src/lib.rs

@@ -3,93 +3,28 @@
 pub extern crate bytes;
 pub extern crate h2;
 pub extern crate http;
+
+#[macro_use]
 pub extern crate tokio_io;
 pub extern crate futures;
 pub extern crate mock_io;
 pub extern crate env_logger;
 
 #[macro_use]
-pub mod codec;
+mod assert;
 
-pub use self::futures::{
-    Future,
-    Sink,
-    Stream,
-};
-pub use self::futures::future::poll_fn;
+#[macro_use]
+pub mod raw;
 
-pub use self::http::{
-    request,
-    response,
-    Request,
-    Response,
-    Method,
-    HeaderMap,
-    StatusCode,
-};
+pub mod prelude;
+pub mod mock;
 
-pub use self::h2::*;
-pub use self::h2::client::{self, Client};
-pub use self::h2::server::{self, Server};
+mod future_ext;
 
+pub use future_ext::{FutureExt, Unwrap};
+
+// This is our test Codec type
 pub type Codec<T> = h2::Codec<T, ::std::io::Cursor<::bytes::Bytes>>;
 
-pub use self::bytes::{
-    Buf,
-    BufMut,
-    Bytes,
-    BytesMut,
-    IntoBuf,
-};
-
-pub use std::time::Duration;
-
-use tokio_io::{AsyncRead, AsyncWrite};
-
-pub trait MockH2 {
-    fn handshake(&mut self) -> &mut Self;
-}
-
-impl MockH2 for mock_io::Builder {
-    fn handshake(&mut self) -> &mut Self {
-        self.write(b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n")
-            // Settings frame
-            .write(frames::SETTINGS)
-            .read(frames::SETTINGS)
-            .read(frames::SETTINGS_ACK)
-    }
-}
-
-pub trait ClientExt {
-    fn run<F: Future>(&mut self, f: F) -> Result<F::Item, F::Error>;
-}
-
-impl<T, B> ClientExt for Client<T, B>
-    where T: AsyncRead + AsyncWrite + 'static,
-          B: IntoBuf + 'static,
-{
-    fn run<F: Future>(&mut self, f: F) -> Result<F::Item, F::Error> {
-        use futures::future::{self, Future};
-        use futures::future::Either::*;
-
-        let res = future::poll_fn(|| self.poll())
-            .select2(f).wait();
-
-        match res {
-            Ok(A((_, b))) => {
-                // Connection is done...
-                b.wait()
-            }
-            Ok(B((v, _))) => return Ok(v),
-            Err(A((e, _))) => panic!("err: {:?}", e),
-            Err(B((e, _))) => return Err(e),
-        }
-    }
-}
-
-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];
-}
+// This is the frame type that is sent
+pub type SendFrame = h2::frame::Frame<::std::io::Cursor<::bytes::Bytes>>;