160 lines
3.8 KiB
Rust
160 lines
3.8 KiB
Rust
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)
|
|
}
|
|
}
|