Move tests and support utilities to sub crates. (#268)
These crates will not be published to crates.io, but moving them allows `tower-h2` to also depend on the test utilities.
This commit is contained in:
Carl Lerche
GitHub
860
tests/h2-tests/tests/client_request.rs
Normal file
860
tests/h2-tests/tests/client_request.rs
Normal file
@@ -0,0 +1,860 @@
|
||||
#[macro_use]
|
||||
extern crate log;
|
||||
extern crate h2_support;
|
||||
|
||||
use h2_support::prelude::*;
|
||||
|
||||
#[test]
|
||||
fn handshake() {
|
||||
let _ = ::env_logger::try_init();
|
||||
|
||||
let mock = mock_io::Builder::new()
|
||||
.handshake()
|
||||
.write(SETTINGS_ACK)
|
||||
.build();
|
||||
|
||||
let (_client, h2) = client::handshake(mock).wait().unwrap();
|
||||
|
||||
trace!("hands have been shook");
|
||||
|
||||
// At this point, the connection should be closed
|
||||
h2.wait().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn client_other_thread() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://http2.akamai.com/")
|
||||
.eos(),
|
||||
)
|
||||
.send_frame(frames::headers(1).response(200).eos())
|
||||
.close();
|
||||
|
||||
let h2 = client::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, h2)| {
|
||||
::std::thread::spawn(move || {
|
||||
let request = Request::builder()
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
let res = client
|
||||
.send_request(request, true)
|
||||
.unwrap().0
|
||||
.wait()
|
||||
.expect("request");
|
||||
assert_eq!(res.status(), StatusCode::OK);
|
||||
});
|
||||
|
||||
h2.expect("h2")
|
||||
});
|
||||
h2.join(srv).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recv_invalid_server_stream_id() {
|
||||
let _ = ::env_logger::try_init();
|
||||
|
||||
let mock = mock_io::Builder::new()
|
||||
.handshake()
|
||||
// Write GET /
|
||||
.write(&[
|
||||
0, 0, 0x10, 1, 5, 0, 0, 0, 1, 0x82, 0x87, 0x41, 0x8B, 0x9D, 0x29,
|
||||
0xAC, 0x4B, 0x8F, 0xA8, 0xE9, 0x19, 0x97, 0x21, 0xE9, 0x84,
|
||||
])
|
||||
.write(SETTINGS_ACK)
|
||||
// Read response
|
||||
.read(&[0, 0, 1, 1, 5, 0, 0, 0, 2, 137])
|
||||
// Write GO_AWAY
|
||||
.write(&[0, 0, 8, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
|
||||
.build();
|
||||
|
||||
let (mut client, h2) = client::handshake(mock).wait().unwrap();
|
||||
|
||||
// Send the request
|
||||
let request = Request::builder()
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
info!("sending request");
|
||||
let (response, _) = client.send_request(request, true).unwrap();
|
||||
|
||||
// The connection errors
|
||||
assert!(h2.wait().is_err());
|
||||
|
||||
// The stream errors
|
||||
assert!(response.wait().is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn request_stream_id_overflows() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
|
||||
let h2 = client::Builder::new()
|
||||
.initial_stream_id(::std::u32::MAX >> 1)
|
||||
.handshake::<_, Bytes>(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, h2)| {
|
||||
let request = Request::builder()
|
||||
.method(Method::GET)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
// first request is allowed
|
||||
let (response, _) = client.send_request(request, true).unwrap();
|
||||
|
||||
h2.drive(response).and_then(move |(h2, _)| {
|
||||
let request = Request::builder()
|
||||
.method(Method::GET)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
// second cannot use the next stream id, it's over
|
||||
|
||||
let poll_err = client.poll_ready().unwrap_err();
|
||||
assert_eq!(poll_err.to_string(), "user error: stream ID overflowed");
|
||||
|
||||
let err = client.send_request(request, true).unwrap_err();
|
||||
assert_eq!(err.to_string(), "user error: stream ID overflowed");
|
||||
|
||||
h2.expect("h2").map(|ret| {
|
||||
// Hold on to the `client` handle to avoid sending a GO_AWAY
|
||||
// frame.
|
||||
drop(client);
|
||||
ret
|
||||
})
|
||||
})
|
||||
});
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(
|
||||
frames::headers(::std::u32::MAX >> 1)
|
||||
.request("GET", "https://example.com/")
|
||||
.eos(),
|
||||
)
|
||||
.send_frame(
|
||||
frames::headers(::std::u32::MAX >> 1)
|
||||
.response(200)
|
||||
.eos()
|
||||
)
|
||||
.idle_ms(10)
|
||||
.close();
|
||||
|
||||
h2.join(srv).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn client_builder_max_concurrent_streams() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
let mut settings = frame::Settings::default();
|
||||
settings.set_max_concurrent_streams(Some(1));
|
||||
|
||||
let srv = srv
|
||||
.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_custom_settings(settings)
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://example.com/")
|
||||
.eos()
|
||||
)
|
||||
.send_frame(frames::headers(1).response(200).eos())
|
||||
.close();
|
||||
|
||||
let mut builder = client::Builder::new();
|
||||
builder.max_concurrent_streams(1);
|
||||
|
||||
let h2 = builder
|
||||
.handshake::<_, Bytes>(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, h2)| {
|
||||
let request = Request::builder()
|
||||
.method(Method::GET)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let (response, _) = client.send_request(request, true).unwrap();
|
||||
h2.drive(response).map(move |(h2, _)| (client, h2))
|
||||
});
|
||||
|
||||
h2.join(srv).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn request_over_max_concurrent_streams_errors() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
|
||||
let srv = srv.assert_client_handshake_with_settings(frames::settings()
|
||||
// super tiny server
|
||||
.max_concurrent_streams(1))
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("POST", "https://example.com/")
|
||||
.eos(),
|
||||
)
|
||||
.send_frame(frames::headers(1).response(200).eos())
|
||||
.recv_frame(frames::headers(3).request("POST", "https://example.com/"))
|
||||
.send_frame(frames::headers(3).response(200))
|
||||
.recv_frame(frames::data(3, "hello").eos())
|
||||
.send_frame(frames::data(3, "").eos())
|
||||
.recv_frame(frames::headers(5).request("POST", "https://example.com/"))
|
||||
.send_frame(frames::headers(5).response(200))
|
||||
.recv_frame(frames::data(5, "hello").eos())
|
||||
.send_frame(frames::data(5, "").eos())
|
||||
.close();
|
||||
|
||||
let h2 = client::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, h2)| {
|
||||
// we send a simple req here just to drive the connection so we can
|
||||
// receive the server settings.
|
||||
let request = Request::builder()
|
||||
.method(Method::POST)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
// first request is allowed
|
||||
let (response, _) = client.send_request(request, true).unwrap();
|
||||
h2.drive(response).map(move |(h2, _)| (client, h2))
|
||||
})
|
||||
.and_then(|(mut client, h2)| {
|
||||
let request = Request::builder()
|
||||
.method(Method::POST)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
// first request is allowed
|
||||
let (resp1, mut stream1) = client.send_request(request, false).unwrap();
|
||||
|
||||
let request = Request::builder()
|
||||
.method(Method::POST)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
// second request is put into pending_open
|
||||
let (resp2, mut stream2) = client.send_request(request, false).unwrap();
|
||||
|
||||
let request = Request::builder()
|
||||
.method(Method::GET)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
// third stream is over max concurrent
|
||||
assert!(client.poll_ready().expect("poll_ready").is_not_ready());
|
||||
|
||||
let err = client.send_request(request, true).unwrap_err();
|
||||
assert_eq!(err.to_string(), "user error: rejected");
|
||||
|
||||
stream1.send_data("hello".into(), true).expect("req send_data");
|
||||
|
||||
h2.drive(resp1.expect("req")).and_then(move |(h2, _)| {
|
||||
stream2.send_data("hello".into(), true)
|
||||
.expect("req2 send_data");
|
||||
h2.expect("h2").join(resp2.expect("req2"))
|
||||
})
|
||||
});
|
||||
|
||||
h2.join(srv).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn send_request_poll_ready_when_connection_error() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
|
||||
let srv = srv.assert_client_handshake_with_settings(frames::settings()
|
||||
// super tiny server
|
||||
.max_concurrent_streams(1))
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("POST", "https://example.com/")
|
||||
.eos(),
|
||||
)
|
||||
.send_frame(frames::headers(1).response(200).eos())
|
||||
.recv_frame(frames::headers(3).request("POST", "https://example.com/").eos())
|
||||
.send_frame(frames::headers(8).response(200).eos())
|
||||
//.recv_frame(frames::headers(5).request("POST", "https://example.com/").eos())
|
||||
.close();
|
||||
|
||||
let h2 = client::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, h2)| {
|
||||
// we send a simple req here just to drive the connection so we can
|
||||
// receive the server settings.
|
||||
let request = Request::builder()
|
||||
.method(Method::POST)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
// first request is allowed
|
||||
let (response, _) = client.send_request(request, true).unwrap();
|
||||
h2.drive(response).map(move |(h2, _)| (client, h2))
|
||||
})
|
||||
.and_then(|(mut client, h2)| {
|
||||
let request = Request::builder()
|
||||
.method(Method::POST)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
// first request is allowed
|
||||
let (resp1, _) = client.send_request(request, true).unwrap();
|
||||
|
||||
let request = Request::builder()
|
||||
.method(Method::POST)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
// second request is put into pending_open
|
||||
let (resp2, _) = client.send_request(request, true).unwrap();
|
||||
|
||||
// third stream is over max concurrent
|
||||
let until_ready = futures::future::poll_fn(move || {
|
||||
client.poll_ready()
|
||||
}).expect_err("client poll_ready").then(|_| Ok(()));
|
||||
|
||||
// a FuturesUnordered is used on purpose!
|
||||
//
|
||||
// We don't want a join, since any of the other futures notifying
|
||||
// will make the until_ready future polled again, but we are
|
||||
// specifically testing that until_ready gets notified on its own.
|
||||
let mut unordered = futures::stream::FuturesUnordered::<Box<Future<Item=(), Error=()>>>::new();
|
||||
unordered.push(Box::new(until_ready));
|
||||
unordered.push(Box::new(h2.expect_err("client conn").then(|_| Ok(()))));
|
||||
unordered.push(Box::new(resp1.expect_err("req1").then(|_| Ok(()))));
|
||||
unordered.push(Box::new(resp2.expect_err("req2").then(|_| Ok(()))));
|
||||
|
||||
unordered.for_each(|_| Ok(()))
|
||||
});
|
||||
|
||||
h2.join(srv).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn http_11_request_without_scheme_or_authority() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "/")
|
||||
.scheme("http")
|
||||
.eos(),
|
||||
)
|
||||
.send_frame(frames::headers(1).response(200).eos())
|
||||
.close();
|
||||
|
||||
let h2 = client::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, h2)| {
|
||||
// we send a simple req here just to drive the connection so we can
|
||||
// receive the server settings.
|
||||
let request = Request::builder()
|
||||
.method(Method::GET)
|
||||
.uri("/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
// first request is allowed
|
||||
let (response, _) = client.send_request(request, true).unwrap();
|
||||
h2.drive(response)
|
||||
.map(move |(h2, _)| (client, h2))
|
||||
});
|
||||
|
||||
h2.join(srv).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn http_2_request_without_scheme_or_authority() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.close();
|
||||
|
||||
let h2 = client::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, h2)| {
|
||||
// we send a simple req here just to drive the connection so we can
|
||||
// receive the server settings.
|
||||
let request = Request::builder()
|
||||
.version(Version::HTTP_2)
|
||||
.method(Method::GET)
|
||||
.uri("/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
// first request is allowed
|
||||
assert!(client.send_request(request, true).is_err());
|
||||
h2.expect("h2").map(|ret| {
|
||||
// Hold on to the `client` handle to avoid sending a GO_AWAY frame.
|
||||
drop(client);
|
||||
ret
|
||||
})
|
||||
});
|
||||
|
||||
h2.join(srv).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn request_with_h1_version() {}
|
||||
|
||||
#[test]
|
||||
fn request_with_connection_headers() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
// can't assert full handshake, since client never sends a request, and
|
||||
// thus never bothers to ack the settings...
|
||||
let srv = srv.read_preface()
|
||||
.unwrap()
|
||||
.recv_frame(frames::settings())
|
||||
// goaway is required to make sure the connection closes because
|
||||
// of no active streams
|
||||
.recv_frame(frames::go_away(0))
|
||||
.close();
|
||||
|
||||
let headers = vec![
|
||||
("connection", "foo"),
|
||||
("keep-alive", "5"),
|
||||
("proxy-connection", "bar"),
|
||||
("transfer-encoding", "chunked"),
|
||||
("upgrade", "HTTP/2.0"),
|
||||
("te", "boom"),
|
||||
];
|
||||
|
||||
let client = client::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(move |(mut client, conn)| {
|
||||
for (name, val) in headers {
|
||||
let req = Request::builder()
|
||||
.uri("https://http2.akamai.com/")
|
||||
.header(name, val)
|
||||
.body(())
|
||||
.unwrap();
|
||||
let err = client.send_request(req, true).expect_err(name);
|
||||
|
||||
assert_eq!(err.to_string(), "user error: malformed headers");
|
||||
}
|
||||
conn.unwrap()
|
||||
});
|
||||
|
||||
client.join(srv).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn connection_close_notifies_response_future() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://http2.akamai.com/")
|
||||
.eos(),
|
||||
)
|
||||
// don't send any response, just close
|
||||
.close();
|
||||
|
||||
let client = client::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, conn)| {
|
||||
let request = Request::builder()
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let req = client
|
||||
.send_request(request, true)
|
||||
.expect("send_request1")
|
||||
.0
|
||||
.then(|res| {
|
||||
let err = res.expect_err("response");
|
||||
assert_eq!(
|
||||
err.to_string(),
|
||||
"broken pipe"
|
||||
);
|
||||
Ok(())
|
||||
});
|
||||
|
||||
conn.expect("conn").join(req)
|
||||
});
|
||||
|
||||
client.join(srv).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn connection_close_notifies_client_poll_ready() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://http2.akamai.com/")
|
||||
.eos(),
|
||||
)
|
||||
.close();
|
||||
|
||||
let client = client::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, conn)| {
|
||||
let request = Request::builder()
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let req = client
|
||||
.send_request(request, true)
|
||||
.expect("send_request1")
|
||||
.0
|
||||
.then(|res| {
|
||||
let err = res.expect_err("response");
|
||||
assert_eq!(
|
||||
err.to_string(),
|
||||
"broken pipe"
|
||||
);
|
||||
Ok::<_, ()>(())
|
||||
});
|
||||
|
||||
conn.drive(req)
|
||||
.and_then(move |(_conn, _)| {
|
||||
let err = client.poll_ready().expect_err("poll_ready");
|
||||
assert_eq!(
|
||||
err.to_string(),
|
||||
"broken pipe"
|
||||
);
|
||||
Ok(())
|
||||
})
|
||||
});
|
||||
|
||||
client.join(srv).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sending_request_on_closed_connection() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://http2.akamai.com/")
|
||||
.eos(),
|
||||
)
|
||||
.send_frame(frames::headers(1).response(200).eos())
|
||||
// a bad frame!
|
||||
.send_frame(frames::headers(0).response(200).eos())
|
||||
.close();
|
||||
|
||||
let h2 = client::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, h2)| {
|
||||
let request = Request::builder()
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
// first request works
|
||||
let req = client
|
||||
.send_request(request, true)
|
||||
.expect("send_request1")
|
||||
.0
|
||||
.expect("response1")
|
||||
.map(|_| ());
|
||||
|
||||
// after finish request1, there should be a conn error
|
||||
let h2 = h2.then(|res| {
|
||||
res.expect_err("h2 error");
|
||||
Ok::<(), ()>(())
|
||||
});
|
||||
|
||||
h2.select(req)
|
||||
.then(|res| match res {
|
||||
Ok((_, next)) => next,
|
||||
Err(_) => unreachable!("both selected futures cannot error"),
|
||||
})
|
||||
.map(move |_| client)
|
||||
})
|
||||
.and_then(|mut client| {
|
||||
let poll_err = client.poll_ready().unwrap_err();
|
||||
let msg = "protocol error: unspecific protocol error detected";
|
||||
assert_eq!(poll_err.to_string(), msg);
|
||||
|
||||
let request = Request::builder()
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
let send_err = client.send_request(request, true).unwrap_err();
|
||||
assert_eq!(send_err.to_string(), msg);
|
||||
|
||||
Ok(())
|
||||
});
|
||||
|
||||
h2.join(srv).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recv_too_big_headers() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_custom_settings(
|
||||
frames::settings()
|
||||
.max_header_list_size(10)
|
||||
)
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://http2.akamai.com/")
|
||||
.eos(),
|
||||
)
|
||||
.recv_frame(
|
||||
frames::headers(3)
|
||||
.request("GET", "https://http2.akamai.com/")
|
||||
.eos(),
|
||||
)
|
||||
.send_frame(frames::headers(1).response(200).eos())
|
||||
.send_frame(frames::headers(3).response(200))
|
||||
// no reset for 1, since it's closed anyways
|
||||
// but reset for 3, since server hasn't closed stream
|
||||
.recv_frame(frames::reset(3).refused())
|
||||
.idle_ms(10)
|
||||
.close();
|
||||
|
||||
let client = client::Builder::new()
|
||||
.max_header_list_size(10)
|
||||
.handshake::<_, Bytes>(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, conn)| {
|
||||
let request = Request::builder()
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let req1 = client
|
||||
.send_request(request, true)
|
||||
.expect("send_request")
|
||||
.0
|
||||
.expect_err("response1")
|
||||
.map(|err| {
|
||||
assert_eq!(
|
||||
err.reason(),
|
||||
Some(Reason::REFUSED_STREAM)
|
||||
);
|
||||
});
|
||||
|
||||
let request = Request::builder()
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let req2 = client
|
||||
.send_request(request, true)
|
||||
.expect("send_request")
|
||||
.0
|
||||
.expect_err("response2")
|
||||
.map(|err| {
|
||||
assert_eq!(
|
||||
err.reason(),
|
||||
Some(Reason::REFUSED_STREAM)
|
||||
);
|
||||
});
|
||||
|
||||
conn.drive(req1.join(req2))
|
||||
.and_then(|(conn, _)| conn.expect("client"))
|
||||
.map(|c| (c, client))
|
||||
});
|
||||
|
||||
client.join(srv).wait().expect("wait");
|
||||
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pending_send_request_gets_reset_by_peer_properly() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
let payload = [0; (frame::DEFAULT_INITIAL_WINDOW_SIZE * 2) as usize];
|
||||
let max_frame_size = frame::DEFAULT_MAX_FRAME_SIZE as usize;
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://http2.akamai.com/"),
|
||||
)
|
||||
// Note that we can only send up to ~4 frames of data by default
|
||||
.recv_frame(frames::data(1, &payload[0..max_frame_size]))
|
||||
.recv_frame(frames::data(1, &payload[max_frame_size..(max_frame_size*2)]))
|
||||
.recv_frame(frames::data(1, &payload[(max_frame_size*2)..(max_frame_size*3)]))
|
||||
.recv_frame(frames::data(1, &payload[(max_frame_size*3)..(max_frame_size*4-1)]))
|
||||
|
||||
.idle_ms(100)
|
||||
|
||||
.send_frame(frames::reset(1).refused())
|
||||
// Because all active requests are finished, connection should shutdown
|
||||
// and send a GO_AWAY frame. If the reset stream is bugged (and doesn't
|
||||
// count towards concurrency limit), then connection will not send
|
||||
// a GO_AWAY and this test will fail.
|
||||
.recv_frame(frames::go_away(0))
|
||||
|
||||
.close();
|
||||
|
||||
let client = client::Builder::new()
|
||||
.handshake::<_, Bytes>(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, conn)| {
|
||||
let request = Request::builder()
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let (response, mut stream) = client
|
||||
.send_request(request, false)
|
||||
.expect("send_request");
|
||||
|
||||
let response = response.expect_err("response")
|
||||
.map(|err| {
|
||||
assert_eq!(
|
||||
err.reason(),
|
||||
Some(Reason::REFUSED_STREAM)
|
||||
);
|
||||
});
|
||||
|
||||
// Send the data
|
||||
stream.send_data(payload[..].into(), true).unwrap();
|
||||
|
||||
conn.drive(response)
|
||||
.and_then(|(conn, _)| conn.expect("client"))
|
||||
});
|
||||
|
||||
client.join(srv).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn request_without_path() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(frames::headers(1).request("GET", "http://example.com/").eos())
|
||||
.send_frame(frames::headers(1).response(200).eos())
|
||||
.close();
|
||||
|
||||
let client = client::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(move |(mut client, conn)| {
|
||||
// Note the lack of trailing slash.
|
||||
let request = Request::get("http://example.com")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let (response, _) = client.send_request(request, true).unwrap();
|
||||
|
||||
conn.drive(response)
|
||||
});
|
||||
|
||||
client.join(srv).wait().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn request_options_with_star() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
// Note the lack of trailing slash.
|
||||
let uri = uri::Uri::from_parts({
|
||||
let mut parts = uri::Parts::default();
|
||||
parts.scheme = Some(uri::Scheme::HTTP);
|
||||
parts.authority = Some(uri::Authority::from_shared("example.com".into()).unwrap());
|
||||
parts.path_and_query = Some(uri::PathAndQuery::from_static("*"));
|
||||
parts
|
||||
}).unwrap();
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(frames::headers(1).request("OPTIONS", uri.clone()).eos())
|
||||
.send_frame(frames::headers(1).response(200).eos())
|
||||
.close();
|
||||
|
||||
let client = client::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(move |(mut client, conn)| {
|
||||
let request = Request::builder()
|
||||
.method(Method::OPTIONS)
|
||||
.uri(uri)
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let (response, _) = client.send_request(request, true).unwrap();
|
||||
|
||||
conn.drive(response)
|
||||
});
|
||||
|
||||
client.join(srv).wait().unwrap();
|
||||
}
|
||||
|
||||
const SETTINGS: &'static [u8] = &[0, 0, 0, 4, 0, 0, 0, 0, 0];
|
||||
const SETTINGS_ACK: &'static [u8] = &[0, 0, 0, 4, 1, 0, 0, 0, 0];
|
||||
|
||||
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(SETTINGS)
|
||||
.read(SETTINGS)
|
||||
.read(SETTINGS_ACK)
|
||||
}
|
||||
}
|
||||
194
tests/h2-tests/tests/codec_read.rs
Normal file
194
tests/h2-tests/tests/codec_read.rs
Normal file
@@ -0,0 +1,194 @@
|
||||
#[macro_use]
|
||||
extern crate h2_support;
|
||||
|
||||
use h2_support::prelude::*;
|
||||
|
||||
use std::error::Error;
|
||||
|
||||
#[test]
|
||||
fn read_none() {
|
||||
let mut codec = Codec::from(mock_io::Builder::new().build());
|
||||
|
||||
assert_closed!(codec);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn read_frame_too_big() {}
|
||||
|
||||
// ===== DATA =====
|
||||
|
||||
#[test]
|
||||
fn read_data_no_padding() {
|
||||
let mut codec = raw_codec! {
|
||||
read => [
|
||||
0, 0, 5, 0, 0, 0, 0, 0, 1,
|
||||
"hello",
|
||||
];
|
||||
};
|
||||
|
||||
let data = poll_data!(codec);
|
||||
assert_eq!(data.stream_id(), 1);
|
||||
assert_eq!(data.payload(), &b"hello"[..]);
|
||||
assert!(!data.is_end_stream());
|
||||
|
||||
assert_closed!(codec);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_data_empty_payload() {
|
||||
let mut codec = raw_codec! {
|
||||
read => [
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 1,
|
||||
];
|
||||
};
|
||||
|
||||
let data = poll_data!(codec);
|
||||
assert_eq!(data.stream_id(), 1);
|
||||
assert_eq!(data.payload(), &b""[..]);
|
||||
assert!(!data.is_end_stream());
|
||||
|
||||
assert_closed!(codec);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_data_end_stream() {
|
||||
let mut codec = raw_codec! {
|
||||
read => [
|
||||
0, 0, 5, 0, 1, 0, 0, 0, 1,
|
||||
"hello",
|
||||
];
|
||||
};
|
||||
|
||||
let data = poll_data!(codec);
|
||||
assert_eq!(data.stream_id(), 1);
|
||||
assert_eq!(data.payload(), &b"hello"[..]);
|
||||
assert!(data.is_end_stream());
|
||||
|
||||
assert_closed!(codec);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_data_padding() {
|
||||
let mut codec = raw_codec! {
|
||||
read => [
|
||||
0, 0, 11, 0, 0x8, 0, 0, 0, 1,
|
||||
5, // Pad length
|
||||
"hello", // Data
|
||||
"world", // Padding
|
||||
];
|
||||
};
|
||||
|
||||
let data = poll_data!(codec);
|
||||
assert_eq!(data.stream_id(), 1);
|
||||
assert_eq!(data.payload(), &b"hello"[..]);
|
||||
assert!(!data.is_end_stream());
|
||||
|
||||
assert_closed!(codec);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_data_stream_id_zero() {
|
||||
let mut codec = raw_codec! {
|
||||
read => [
|
||||
0, 0, 5, 0, 0, 0, 0, 0, 0,
|
||||
"hello", // Data
|
||||
];
|
||||
};
|
||||
|
||||
poll_err!(codec);
|
||||
}
|
||||
|
||||
// ===== HEADERS =====
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn read_headers_without_pseudo() {}
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn read_headers_with_pseudo() {}
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn read_headers_empty_payload() {}
|
||||
|
||||
#[test]
|
||||
fn read_continuation_frames() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
let large = build_large_headers();
|
||||
let frame = large.iter().fold(
|
||||
frames::headers(1).response(200),
|
||||
|frame, &(name, ref value)| frame.field(name, &value[..]),
|
||||
).eos();
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://http2.akamai.com/")
|
||||
.eos(),
|
||||
)
|
||||
.send_frame(frame)
|
||||
.close();
|
||||
|
||||
let client = client::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, conn)| {
|
||||
let request = Request::builder()
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let req = client
|
||||
.send_request(request, true)
|
||||
.expect("send_request")
|
||||
.0
|
||||
.expect("response")
|
||||
.map(move |res| {
|
||||
assert_eq!(res.status(), StatusCode::OK);
|
||||
let (head, _body) = res.into_parts();
|
||||
let expected = large.iter().fold(HeaderMap::new(), |mut map, &(name, ref value)| {
|
||||
use h2_support::frames::HttpTryInto;
|
||||
map.append(name, value.as_str().try_into().unwrap());
|
||||
map
|
||||
});
|
||||
assert_eq!(head.headers, expected);
|
||||
});
|
||||
|
||||
conn.drive(req)
|
||||
.and_then(move |(h2, _)| {
|
||||
h2.expect("client")
|
||||
}).map(|c| (client, c))
|
||||
});
|
||||
|
||||
client.join(srv).wait().expect("wait");
|
||||
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn update_max_frame_len_at_rest() {
|
||||
let _ = ::env_logger::try_init();
|
||||
// TODO: add test for updating max frame length in flight as well?
|
||||
let mut codec = raw_codec! {
|
||||
read => [
|
||||
0, 0, 5, 0, 0, 0, 0, 0, 1,
|
||||
"hello",
|
||||
0, 64, 1, 0, 0, 0, 0, 0, 1,
|
||||
vec![0; 16_385],
|
||||
];
|
||||
};
|
||||
|
||||
assert_eq!(poll_data!(codec).payload(), &b"hello"[..]);
|
||||
|
||||
codec.set_max_recv_frame_size(16_384);
|
||||
|
||||
assert_eq!(codec.max_recv_frame_size(), 16_384);
|
||||
assert_eq!(
|
||||
codec.poll().unwrap_err().description(),
|
||||
"frame with invalid size"
|
||||
);
|
||||
}
|
||||
63
tests/h2-tests/tests/codec_write.rs
Normal file
63
tests/h2-tests/tests/codec_write.rs
Normal file
@@ -0,0 +1,63 @@
|
||||
extern crate h2_support;
|
||||
|
||||
use h2_support::prelude::*;
|
||||
|
||||
#[test]
|
||||
fn write_continuation_frames() {
|
||||
// An invalid dependency ID results in a stream level error. The hpack
|
||||
// payload should still be decoded.
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
let large = build_large_headers();
|
||||
|
||||
// Build the large request frame
|
||||
let frame = large.iter().fold(
|
||||
frames::headers(1).request("GET", "https://http2.akamai.com/"),
|
||||
|frame, &(name, ref value)| frame.field(name, &value[..]));
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(frame.eos())
|
||||
.send_frame(
|
||||
frames::headers(1)
|
||||
.response(204)
|
||||
.eos(),
|
||||
)
|
||||
.close();
|
||||
|
||||
let client = client::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, conn)| {
|
||||
let mut request = Request::builder();
|
||||
request.uri("https://http2.akamai.com/");
|
||||
|
||||
for &(name, ref value) in &large {
|
||||
request.header(name, &value[..]);
|
||||
}
|
||||
|
||||
let request = request
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let req = client
|
||||
.send_request(request, true)
|
||||
.expect("send_request1")
|
||||
.0
|
||||
.then(|res| {
|
||||
let response = res.unwrap();
|
||||
assert_eq!(response.status(), StatusCode::NO_CONTENT);
|
||||
Ok::<_, ()>(())
|
||||
});
|
||||
|
||||
conn.drive(req)
|
||||
.and_then(move |(h2, _)| {
|
||||
h2.unwrap()
|
||||
}).map(|c| {
|
||||
(c, client)
|
||||
})
|
||||
});
|
||||
|
||||
client.join(srv).wait().expect("wait");
|
||||
}
|
||||
1204
tests/h2-tests/tests/flow_control.rs
Normal file
1204
tests/h2-tests/tests/flow_control.rs
Normal file
File diff suppressed because it is too large
Load Diff
110
tests/h2-tests/tests/ping_pong.rs
Normal file
110
tests/h2-tests/tests/ping_pong.rs
Normal file
@@ -0,0 +1,110 @@
|
||||
#[macro_use]
|
||||
extern crate h2_support;
|
||||
|
||||
use h2_support::prelude::*;
|
||||
|
||||
#[test]
|
||||
fn recv_single_ping() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (m, mock) = mock::new();
|
||||
|
||||
// Create the handshake
|
||||
let h2 = client::handshake(m)
|
||||
.unwrap()
|
||||
.and_then(|(client, conn)| {
|
||||
conn.unwrap()
|
||||
.map(|c| (client, c))
|
||||
});
|
||||
|
||||
let mock = mock.assert_client_handshake()
|
||||
.unwrap()
|
||||
.and_then(|(_, mut mock)| {
|
||||
let frame = frame::Ping::new(Default::default());
|
||||
mock.send(frame.into()).unwrap();
|
||||
|
||||
mock.into_future().unwrap()
|
||||
})
|
||||
.and_then(|(frame, _)| {
|
||||
let pong = assert_ping!(frame.unwrap());
|
||||
|
||||
// Payload is correct
|
||||
assert_eq!(*pong.payload(), <[u8; 8]>::default());
|
||||
|
||||
// Is ACK
|
||||
assert!(pong.is_ack());
|
||||
|
||||
Ok(())
|
||||
});
|
||||
|
||||
let _ = h2.join(mock).wait().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recv_multiple_pings() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, client) = mock::new();
|
||||
|
||||
let client = client.assert_server_handshake()
|
||||
.expect("client handshake")
|
||||
.recv_settings()
|
||||
.send_frame(frames::ping([1; 8]))
|
||||
.send_frame(frames::ping([2; 8]))
|
||||
.recv_frame(frames::ping([1; 8]).pong())
|
||||
.recv_frame(frames::ping([2; 8]).pong())
|
||||
.close();
|
||||
|
||||
let srv = server::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(|srv| {
|
||||
// future of first request, which never comes
|
||||
srv.into_future().unwrap()
|
||||
});
|
||||
|
||||
srv.join(client).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pong_has_highest_priority() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, client) = mock::new();
|
||||
|
||||
let data = Bytes::from(vec![0; 16_384]);
|
||||
|
||||
let client = client.assert_server_handshake()
|
||||
.expect("client handshake")
|
||||
.recv_settings()
|
||||
.send_frame(
|
||||
frames::headers(1)
|
||||
.request("POST", "https://http2.akamai.com/")
|
||||
)
|
||||
.send_frame(frames::data(1, data.clone()).eos())
|
||||
.send_frame(frames::ping([1; 8]))
|
||||
.recv_frame(frames::ping([1; 8]).pong())
|
||||
.recv_frame(frames::headers(1).response(200).eos())
|
||||
.close();
|
||||
|
||||
let srv = server::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(|srv| {
|
||||
// future of first request
|
||||
srv.into_future().unwrap()
|
||||
}).and_then(move |(reqstream, srv)| {
|
||||
let (req, mut stream) = reqstream.expect("request");
|
||||
assert_eq!(req.method(), "POST");
|
||||
let body = req.into_parts().1;
|
||||
|
||||
body.concat2()
|
||||
.expect("body")
|
||||
.and_then(move |body| {
|
||||
assert_eq!(body.len(), data.len());
|
||||
let res = Response::builder()
|
||||
.status(200)
|
||||
.body(())
|
||||
.unwrap();
|
||||
stream.send_response(res, true).expect("response");
|
||||
srv.into_future().unwrap()
|
||||
})
|
||||
});
|
||||
|
||||
srv.join(client).wait().expect("wait");
|
||||
}
|
||||
440
tests/h2-tests/tests/prioritization.rs
Normal file
440
tests/h2-tests/tests/prioritization.rs
Normal file
@@ -0,0 +1,440 @@
|
||||
#[macro_use]
|
||||
extern crate h2_support;
|
||||
|
||||
use h2_support::{DEFAULT_WINDOW_SIZE};
|
||||
use h2_support::prelude::*;
|
||||
|
||||
#[test]
|
||||
fn single_stream_send_large_body() {
|
||||
let _ = ::env_logger::try_init();
|
||||
|
||||
let payload = [0; 1024];
|
||||
|
||||
let mock = mock_io::Builder::new()
|
||||
.handshake()
|
||||
.write(frames::SETTINGS_ACK)
|
||||
.write(&[
|
||||
// POST /
|
||||
0, 0, 16, 1, 4, 0, 0, 0, 1, 131, 135, 65, 139, 157, 41,
|
||||
172, 75, 143, 168, 233, 25, 151, 33, 233, 132,
|
||||
])
|
||||
.write(&[
|
||||
// DATA
|
||||
0, 4, 0, 0, 1, 0, 0, 0, 1,
|
||||
])
|
||||
.write(&payload[..])
|
||||
// Read response
|
||||
.read(&[0, 0, 1, 1, 5, 0, 0, 0, 1, 0x89])
|
||||
.build();
|
||||
|
||||
let notify = MockNotify::new();
|
||||
let (mut client, mut h2) = client::handshake(mock).wait().unwrap();
|
||||
|
||||
// Poll h2 once to get notifications
|
||||
loop {
|
||||
// Run the connection until all work is done, this handles processing
|
||||
// the handshake.
|
||||
notify.with(|| h2.poll()).unwrap();
|
||||
|
||||
if !notify.is_notified() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
let request = Request::builder()
|
||||
.method(Method::POST)
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let (response, mut stream) = client.send_request(request, false).unwrap();
|
||||
|
||||
// Reserve capacity to send the payload
|
||||
stream.reserve_capacity(payload.len());
|
||||
|
||||
// The capacity should be immediately allocated
|
||||
assert_eq!(stream.capacity(), payload.len());
|
||||
|
||||
// Send the data
|
||||
stream.send_data(payload[..].into(), true).unwrap();
|
||||
|
||||
assert!(notify.is_notified());
|
||||
|
||||
// Get the response
|
||||
let resp = h2.run(response).unwrap();
|
||||
assert_eq!(resp.status(), StatusCode::NO_CONTENT);
|
||||
|
||||
h2.wait().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn multiple_streams_with_payload_greater_than_default_window() {
|
||||
let _ = ::env_logger::try_init();
|
||||
|
||||
let payload = vec![0; 16384*5-1];
|
||||
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
let srv = srv.assert_client_handshake().unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1).request("POST", "https://http2.akamai.com/")
|
||||
)
|
||||
.recv_frame(
|
||||
frames::headers(3).request("POST", "https://http2.akamai.com/")
|
||||
)
|
||||
.recv_frame(
|
||||
frames::headers(5).request("POST", "https://http2.akamai.com/")
|
||||
)
|
||||
.recv_frame(frames::data(1, &payload[0..16_384]))
|
||||
.recv_frame(frames::data(1, &payload[16_384..(16_384*2)]))
|
||||
.recv_frame(frames::data(1, &payload[(16_384*2)..(16_384*3)]))
|
||||
.recv_frame(frames::data(1, &payload[(16_384*3)..(16_384*4-1)]))
|
||||
.send_frame(frames::settings())
|
||||
.recv_frame(frames::settings_ack())
|
||||
.send_frame(frames::headers(1).response(200).eos())
|
||||
.send_frame(frames::headers(3).response(200).eos())
|
||||
.send_frame(frames::headers(5).response(200).eos())
|
||||
.close();
|
||||
|
||||
let client = client::handshake(io).unwrap()
|
||||
.and_then(|(mut client, conn)| {
|
||||
let request1 = Request::post("https://http2.akamai.com/").body(()).unwrap();
|
||||
let request2 = Request::post("https://http2.akamai.com/").body(()).unwrap();
|
||||
let request3 = Request::post("https://http2.akamai.com/").body(()).unwrap();
|
||||
let (response1, mut stream1) = client.send_request(request1, false).unwrap();
|
||||
let (_response2, mut stream2) = client.send_request(request2, false).unwrap();
|
||||
let (_response3, mut stream3) = client.send_request(request3, false).unwrap();
|
||||
|
||||
// The capacity should be immediately
|
||||
// allocated to default window size (smaller than payload)
|
||||
stream1.reserve_capacity(payload.len());
|
||||
assert_eq!(stream1.capacity(), DEFAULT_WINDOW_SIZE);
|
||||
|
||||
stream2.reserve_capacity(payload.len());
|
||||
assert_eq!(stream2.capacity(), 0);
|
||||
|
||||
stream3.reserve_capacity(payload.len());
|
||||
assert_eq!(stream3.capacity(), 0);
|
||||
|
||||
stream1.send_data(payload[..].into(), true).unwrap();
|
||||
|
||||
// hold onto streams so they don't close
|
||||
// stream1 doesn't close because response1 is used
|
||||
conn.drive(response1.expect("response")).map(|c| (c, client, stream2, stream3))
|
||||
})
|
||||
.and_then(|((conn, _res), client, stream2, stream3)| {
|
||||
conn.expect("client").map(|c| (c, client, stream2, stream3))
|
||||
});
|
||||
|
||||
srv.join(client).wait().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn single_stream_send_extra_large_body_multi_frames_one_buffer() {
|
||||
let _ = ::env_logger::try_init();
|
||||
|
||||
let payload = vec![0; 32_768];
|
||||
|
||||
let mock = mock_io::Builder::new()
|
||||
.handshake()
|
||||
.write(frames::SETTINGS_ACK)
|
||||
.write(&[
|
||||
// POST /
|
||||
0, 0, 16, 1, 4, 0, 0, 0, 1, 131, 135, 65, 139, 157, 41,
|
||||
172, 75, 143, 168, 233, 25, 151, 33, 233, 132,
|
||||
])
|
||||
.write(&[
|
||||
// DATA
|
||||
0, 64, 0, 0, 0, 0, 0, 0, 1,
|
||||
])
|
||||
.write(&payload[0..16_384])
|
||||
.write(&[
|
||||
// DATA
|
||||
0, 64, 0, 0, 1, 0, 0, 0, 1,
|
||||
])
|
||||
.write(&payload[16_384..])
|
||||
// Read response
|
||||
.read(&[0, 0, 1, 1, 5, 0, 0, 0, 1, 0x89])
|
||||
.build();
|
||||
|
||||
let notify = MockNotify::new();
|
||||
let (mut client, mut h2) = client::handshake(mock).wait().unwrap();
|
||||
|
||||
// Poll h2 once to get notifications
|
||||
loop {
|
||||
// Run the connection until all work is done, this handles processing
|
||||
// the handshake.
|
||||
notify.with(|| h2.poll()).unwrap();
|
||||
|
||||
if !notify.is_notified() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
let request = Request::builder()
|
||||
.method(Method::POST)
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let (response, mut stream) = client.send_request(request, false).unwrap();
|
||||
|
||||
stream.reserve_capacity(payload.len());
|
||||
|
||||
// The capacity should be immediately allocated
|
||||
assert_eq!(stream.capacity(), payload.len());
|
||||
|
||||
// Send the data
|
||||
stream.send_data(payload.into(), true).unwrap();
|
||||
|
||||
assert!(notify.is_notified());
|
||||
|
||||
// Get the response
|
||||
let resp = h2.run(response).unwrap();
|
||||
assert_eq!(resp.status(), StatusCode::NO_CONTENT);
|
||||
|
||||
h2.wait().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn single_stream_send_body_greater_than_default_window() {
|
||||
let _ = ::env_logger::try_init();
|
||||
|
||||
let payload = vec![0; 16384*5-1];
|
||||
|
||||
let mock = mock_io::Builder::new()
|
||||
.handshake()
|
||||
.write(frames::SETTINGS_ACK)
|
||||
.write(&[
|
||||
// POST /
|
||||
0, 0, 16, 1, 4, 0, 0, 0, 1, 131, 135, 65, 139, 157, 41,
|
||||
172, 75, 143, 168, 233, 25, 151, 33, 233, 132,
|
||||
])
|
||||
.write(&[
|
||||
// DATA
|
||||
0, 64, 0, 0, 0, 0, 0, 0, 1,
|
||||
])
|
||||
.write(&payload[0..16_384])
|
||||
.write(&[
|
||||
// DATA
|
||||
0, 64, 0, 0, 0, 0, 0, 0, 1,
|
||||
])
|
||||
.write(&payload[16_384..(16_384*2)])
|
||||
.write(&[
|
||||
// DATA
|
||||
0, 64, 0, 0, 0, 0, 0, 0, 1,
|
||||
])
|
||||
.write(&payload[(16_384*2)..(16_384*3)])
|
||||
.write(&[
|
||||
// DATA
|
||||
0, 63, 255, 0, 0, 0, 0, 0, 1,
|
||||
])
|
||||
.write(&payload[(16_384*3)..(16_384*4-1)])
|
||||
|
||||
// Read window update
|
||||
.read(&[0, 0, 4, 8, 0, 0, 0, 0, 0, 0, 0, 64, 0])
|
||||
.read(&[0, 0, 4, 8, 0, 0, 0, 0, 1, 0, 0, 64, 0])
|
||||
|
||||
.write(&[
|
||||
// DATA
|
||||
0, 64, 0, 0, 1, 0, 0, 0, 1,
|
||||
])
|
||||
.write(&payload[(16_384*4-1)..(16_384*5-1)])
|
||||
// Read response
|
||||
.read(&[0, 0, 1, 1, 5, 0, 0, 0, 1, 0x89])
|
||||
.build();
|
||||
|
||||
let notify = MockNotify::new();
|
||||
let (mut client, mut h2) = client::handshake(mock).wait().unwrap();
|
||||
|
||||
// Poll h2 once to get notifications
|
||||
loop {
|
||||
// Run the connection until all work is done, this handles processing
|
||||
// the handshake.
|
||||
notify.with(|| h2.poll()).unwrap();
|
||||
|
||||
if !notify.is_notified() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
let request = Request::builder()
|
||||
.method(Method::POST)
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let (response, mut stream) = client.send_request(request, false).unwrap();
|
||||
|
||||
// Flush request head
|
||||
loop {
|
||||
// Run the connection until all work is done, this handles processing
|
||||
// the handshake.
|
||||
notify.with(|| h2.poll()).unwrap();
|
||||
|
||||
if !notify.is_notified() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Send the data
|
||||
stream.send_data(payload.into(), true).unwrap();
|
||||
|
||||
assert!(notify.is_notified());
|
||||
|
||||
// Get the response
|
||||
let resp = h2.run(response).unwrap();
|
||||
assert_eq!(resp.status(), StatusCode::NO_CONTENT);
|
||||
|
||||
h2.wait().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn single_stream_send_extra_large_body_multi_frames_multi_buffer() {
|
||||
let _ = ::env_logger::try_init();
|
||||
|
||||
let payload = vec![0; 32_768];
|
||||
|
||||
let mock = mock_io::Builder::new()
|
||||
// .handshake()
|
||||
.write(b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n")
|
||||
.write(frames::SETTINGS)
|
||||
.read(frames::SETTINGS)
|
||||
// Add wait to force the data writes to chill
|
||||
.wait(Duration::from_millis(10))
|
||||
|
||||
// Rest
|
||||
|
||||
.write(&[
|
||||
// POST /
|
||||
0, 0, 16, 1, 4, 0, 0, 0, 1, 131, 135, 65, 139, 157, 41,
|
||||
172, 75, 143, 168, 233, 25, 151, 33, 233, 132,
|
||||
])
|
||||
.write(&[
|
||||
// DATA
|
||||
0, 64, 0, 0, 0, 0, 0, 0, 1,
|
||||
])
|
||||
.write(&payload[0..16_384])
|
||||
|
||||
.write(frames::SETTINGS_ACK)
|
||||
.read(frames::SETTINGS_ACK)
|
||||
.wait(Duration::from_millis(10))
|
||||
|
||||
.write(&[
|
||||
// DATA
|
||||
0, 64, 0, 0, 1, 0, 0, 0, 1,
|
||||
])
|
||||
.write(&payload[16_384..])
|
||||
// Read response
|
||||
.read(&[0, 0, 1, 1, 5, 0, 0, 0, 1, 0x89])
|
||||
.build();
|
||||
|
||||
let (mut client, mut h2) = client::handshake(mock).wait().unwrap();
|
||||
|
||||
let request = Request::builder()
|
||||
.method(Method::POST)
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let (response, mut stream) = client.send_request(request, false).unwrap();
|
||||
|
||||
stream.reserve_capacity(payload.len());
|
||||
|
||||
// The capacity should be immediately allocated
|
||||
assert_eq!(stream.capacity(), payload.len());
|
||||
|
||||
// Send the data
|
||||
stream.send_data(payload.into(), true).unwrap();
|
||||
|
||||
// Get the response
|
||||
let resp = h2.run(response).unwrap();
|
||||
|
||||
assert_eq!(resp.status(), StatusCode::NO_CONTENT);
|
||||
|
||||
h2.wait().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn send_data_receive_window_update() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (m, mock) = mock::new();
|
||||
|
||||
let h2 = client::handshake(m)
|
||||
.unwrap()
|
||||
.and_then(|(mut client, h2)| {
|
||||
let request = Request::builder()
|
||||
.method(Method::POST)
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
// Send request
|
||||
let (response, mut stream) = client.send_request(request, false).unwrap();
|
||||
|
||||
// Send data frame
|
||||
stream.send_data("hello".into(), false).unwrap();
|
||||
|
||||
stream.reserve_capacity(frame::DEFAULT_INITIAL_WINDOW_SIZE as usize);
|
||||
|
||||
// Wait for capacity
|
||||
h2.drive(util::wait_for_capacity(
|
||||
stream,
|
||||
frame::DEFAULT_INITIAL_WINDOW_SIZE as usize,
|
||||
).map(|s| (response, s)))
|
||||
})
|
||||
.and_then(|(h2, (_r, mut stream))| {
|
||||
let payload = vec![0; frame::DEFAULT_INITIAL_WINDOW_SIZE as usize];
|
||||
stream.send_data(payload.into(), true).unwrap();
|
||||
|
||||
// keep `stream` from being dropped in order to prevent
|
||||
// it from sending an RST_STREAM frame.
|
||||
std::mem::forget(stream);
|
||||
h2.unwrap()
|
||||
});
|
||||
|
||||
let mock = mock.assert_client_handshake().unwrap()
|
||||
.and_then(|(_, mock)| mock.into_future().unwrap())
|
||||
.and_then(|(frame, mock)| {
|
||||
let request = assert_headers!(frame.unwrap());
|
||||
assert!(!request.is_end_stream());
|
||||
mock.into_future().unwrap()
|
||||
})
|
||||
.and_then(|(frame, mut mock)| {
|
||||
let data = assert_data!(frame.unwrap());
|
||||
|
||||
// Update the windows
|
||||
let len = data.payload().len();
|
||||
let f = frame::WindowUpdate::new(StreamId::zero(), len as u32);
|
||||
mock.send(f.into()).unwrap();
|
||||
|
||||
let f = frame::WindowUpdate::new(data.stream_id(), len as u32);
|
||||
mock.send(f.into()).unwrap();
|
||||
|
||||
mock.into_future().unwrap()
|
||||
})
|
||||
// TODO: Dedup the following lines
|
||||
.and_then(|(frame, mock)| {
|
||||
let data = assert_data!(frame.unwrap());
|
||||
assert_eq!(data.payload().len(), frame::DEFAULT_MAX_FRAME_SIZE as usize);
|
||||
mock.into_future().unwrap()
|
||||
})
|
||||
.and_then(|(frame, mock)| {
|
||||
let data = assert_data!(frame.unwrap());
|
||||
assert_eq!(data.payload().len(), frame::DEFAULT_MAX_FRAME_SIZE as usize);
|
||||
mock.into_future().unwrap()
|
||||
})
|
||||
.and_then(|(frame, mock)| {
|
||||
let data = assert_data!(frame.unwrap());
|
||||
assert_eq!(data.payload().len(), frame::DEFAULT_MAX_FRAME_SIZE as usize);
|
||||
mock.into_future().unwrap()
|
||||
})
|
||||
.and_then(|(frame, _)| {
|
||||
let data = assert_data!(frame.unwrap());
|
||||
assert_eq!(data.payload().len(), (frame::DEFAULT_MAX_FRAME_SIZE-1) as usize);
|
||||
Ok(())
|
||||
});
|
||||
|
||||
let _ = h2.join(mock).wait().unwrap();
|
||||
}
|
||||
201
tests/h2-tests/tests/push_promise.rs
Normal file
201
tests/h2-tests/tests/push_promise.rs
Normal file
@@ -0,0 +1,201 @@
|
||||
extern crate h2_support;
|
||||
|
||||
use h2_support::prelude::*;
|
||||
|
||||
#[test]
|
||||
fn recv_push_works() {
|
||||
// tests that by default, received push promises work
|
||||
// TODO: once API exists, read the pushed response
|
||||
let _ = ::env_logger::try_init();
|
||||
|
||||
let (io, srv) = mock::new();
|
||||
let mock = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://http2.akamai.com/")
|
||||
.eos(),
|
||||
)
|
||||
.send_frame(frames::push_promise(1, 2).request("GET", "https://http2.akamai.com/style.css"))
|
||||
.send_frame(frames::headers(1).response(200).eos())
|
||||
.send_frame(frames::headers(2).response(200).eos());
|
||||
|
||||
let h2 = client::handshake(io).unwrap().and_then(|(mut client, h2)| {
|
||||
let request = Request::builder()
|
||||
.method(Method::GET)
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
let req = client
|
||||
.send_request(request, true)
|
||||
.unwrap()
|
||||
.0.unwrap()
|
||||
.and_then(|resp| {
|
||||
assert_eq!(resp.status(), StatusCode::OK);
|
||||
Ok(())
|
||||
});
|
||||
|
||||
h2.drive(req)
|
||||
});
|
||||
|
||||
h2.join(mock).wait().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recv_push_when_push_disabled_is_conn_error() {
|
||||
let _ = ::env_logger::try_init();
|
||||
|
||||
let (io, srv) = mock::new();
|
||||
let mock = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.ignore_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://http2.akamai.com/")
|
||||
.eos(),
|
||||
)
|
||||
.send_frame(frames::push_promise(1, 3).request("GET", "https://http2.akamai.com/style.css"))
|
||||
.send_frame(frames::headers(1).response(200).eos())
|
||||
.recv_frame(frames::go_away(0).protocol_error());
|
||||
|
||||
let h2 = client::Builder::new()
|
||||
.enable_push(false)
|
||||
.handshake::<_, Bytes>(io)
|
||||
.unwrap()
|
||||
.and_then(|(mut client, h2)| {
|
||||
let request = Request::builder()
|
||||
.method(Method::GET)
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let req = client.send_request(request, true).unwrap().0.then(|res| {
|
||||
let err = res.unwrap_err();
|
||||
assert_eq!(
|
||||
err.to_string(),
|
||||
"protocol error: unspecific protocol error detected"
|
||||
);
|
||||
Ok::<(), ()>(())
|
||||
});
|
||||
|
||||
// client should see a protocol error
|
||||
let conn = h2.then(|res| {
|
||||
let err = res.unwrap_err();
|
||||
assert_eq!(
|
||||
err.to_string(),
|
||||
"protocol error: unspecific protocol error detected"
|
||||
);
|
||||
Ok::<(), ()>(())
|
||||
});
|
||||
|
||||
conn.unwrap().join(req)
|
||||
});
|
||||
|
||||
h2.join(mock).wait().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pending_push_promises_reset_when_dropped() {
|
||||
let _ = ::env_logger::try_init();
|
||||
|
||||
let (io, srv) = mock::new();
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://http2.akamai.com/")
|
||||
.eos(),
|
||||
)
|
||||
.send_frame(
|
||||
frames::push_promise(1, 2)
|
||||
.request("GET", "https://http2.akamai.com/style.css")
|
||||
)
|
||||
.send_frame(frames::headers(1).response(200).eos())
|
||||
.recv_frame(frames::reset(2).cancel())
|
||||
.close();
|
||||
|
||||
let client = client::handshake(io).unwrap().and_then(|(mut client, conn)| {
|
||||
let request = Request::builder()
|
||||
.method(Method::GET)
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
let req = client
|
||||
.send_request(request, true)
|
||||
.unwrap()
|
||||
.0.expect("response")
|
||||
.and_then(|resp| {
|
||||
assert_eq!(resp.status(), StatusCode::OK);
|
||||
Ok(())
|
||||
});
|
||||
|
||||
conn.drive(req)
|
||||
.and_then(|(conn, _)| conn.expect("client"))
|
||||
});
|
||||
|
||||
client.join(srv).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recv_push_promise_over_max_header_list_size() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_custom_settings(
|
||||
frames::settings()
|
||||
.max_header_list_size(10)
|
||||
)
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://http2.akamai.com/")
|
||||
.eos(),
|
||||
)
|
||||
.send_frame(frames::push_promise(1, 2).request("GET", "https://http2.akamai.com/style.css"))
|
||||
.recv_frame(frames::reset(2).refused())
|
||||
.send_frame(frames::headers(1).response(200).eos())
|
||||
.idle_ms(10)
|
||||
.close();
|
||||
|
||||
let client = client::Builder::new()
|
||||
.max_header_list_size(10)
|
||||
.handshake::<_, Bytes>(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, conn)| {
|
||||
let request = Request::builder()
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let req = client
|
||||
.send_request(request, true)
|
||||
.expect("send_request")
|
||||
.0
|
||||
.expect_err("response")
|
||||
.map(|err| {
|
||||
assert_eq!(
|
||||
err.reason(),
|
||||
Some(Reason::REFUSED_STREAM)
|
||||
);
|
||||
});
|
||||
|
||||
conn.drive(req)
|
||||
.and_then(|(conn, _)| conn.expect("client"))
|
||||
});
|
||||
client.join(srv).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn recv_push_promise_with_unsafe_method_is_stream_error() {
|
||||
// for instance, when :method = POST
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn recv_push_promise_with_wrong_authority_is_stream_error() {
|
||||
// if server is foo.com, :authority = bar.com is stream error
|
||||
}
|
||||
451
tests/h2-tests/tests/server.rs
Normal file
451
tests/h2-tests/tests/server.rs
Normal file
@@ -0,0 +1,451 @@
|
||||
#![deny(warnings)]
|
||||
|
||||
extern crate h2_support;
|
||||
|
||||
use h2_support::prelude::*;
|
||||
|
||||
const SETTINGS: &'static [u8] = &[0, 0, 0, 4, 0, 0, 0, 0, 0];
|
||||
const SETTINGS_ACK: &'static [u8] = &[0, 0, 0, 4, 1, 0, 0, 0, 0];
|
||||
|
||||
#[test]
|
||||
fn read_preface_in_multiple_frames() {
|
||||
let _ = ::env_logger::try_init();
|
||||
|
||||
let mock = mock_io::Builder::new()
|
||||
.read(b"PRI * HTTP/2.0")
|
||||
.read(b"\r\n\r\nSM\r\n\r\n")
|
||||
.write(SETTINGS)
|
||||
.read(SETTINGS)
|
||||
.write(SETTINGS_ACK)
|
||||
.read(SETTINGS_ACK)
|
||||
.build();
|
||||
|
||||
let h2 = server::handshake(mock).wait().unwrap();
|
||||
|
||||
assert!(Stream::wait(h2).next().is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn server_builder_set_max_concurrent_streams() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, client) = mock::new();
|
||||
|
||||
let mut settings = frame::Settings::default();
|
||||
settings.set_max_concurrent_streams(Some(1));
|
||||
|
||||
let client = client
|
||||
.assert_server_handshake()
|
||||
.unwrap()
|
||||
.recv_custom_settings(settings)
|
||||
.send_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://example.com/"),
|
||||
)
|
||||
.send_frame(
|
||||
frames::headers(3)
|
||||
.request("GET", "https://example.com/"),
|
||||
)
|
||||
.send_frame(frames::data(1, &b"hello"[..]).eos(),)
|
||||
.recv_frame(frames::reset(3).refused())
|
||||
.recv_frame(frames::headers(1).response(200).eos())
|
||||
.close();
|
||||
|
||||
let mut builder = server::Builder::new();
|
||||
builder.max_concurrent_streams(1);
|
||||
|
||||
let h2 = builder
|
||||
.handshake::<_, Bytes>(io)
|
||||
.expect("handshake")
|
||||
.and_then(|srv| {
|
||||
srv.into_future().unwrap().and_then(|(reqstream, srv)| {
|
||||
let (req, mut stream) = reqstream.unwrap();
|
||||
|
||||
assert_eq!(req.method(), &http::Method::GET);
|
||||
|
||||
let rsp =
|
||||
http::Response::builder()
|
||||
.status(200).body(())
|
||||
.unwrap();
|
||||
stream.send_response(rsp, true).unwrap();
|
||||
|
||||
srv.into_future().unwrap()
|
||||
})
|
||||
});
|
||||
|
||||
h2.join(client).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn serve_request() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, client) = mock::new();
|
||||
|
||||
let client = client
|
||||
.assert_server_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.send_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://example.com/")
|
||||
.eos(),
|
||||
)
|
||||
.recv_frame(frames::headers(1).response(200).eos())
|
||||
.close();
|
||||
|
||||
let srv = server::handshake(io).expect("handshake").and_then(|srv| {
|
||||
srv.into_future().unwrap().and_then(|(reqstream, srv)| {
|
||||
let (req, mut stream) = reqstream.unwrap();
|
||||
|
||||
assert_eq!(req.method(), &http::Method::GET);
|
||||
|
||||
let rsp = http::Response::builder().status(200).body(()).unwrap();
|
||||
stream.send_response(rsp, true).unwrap();
|
||||
|
||||
srv.into_future().unwrap()
|
||||
})
|
||||
});
|
||||
|
||||
srv.join(client).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn accept_with_pending_connections_after_socket_close() {}
|
||||
|
||||
#[test]
|
||||
fn recv_invalid_authority() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, client) = mock::new();
|
||||
|
||||
let bad_auth = util::byte_str("not:a/good authority");
|
||||
let mut bad_headers: frame::Headers = frames::headers(1)
|
||||
.request("GET", "https://example.com/")
|
||||
.eos()
|
||||
.into();
|
||||
bad_headers.pseudo_mut().authority = Some(bad_auth);
|
||||
|
||||
let client = client
|
||||
.assert_server_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.send_frame(bad_headers)
|
||||
.recv_frame(frames::reset(1).protocol_error())
|
||||
.close();
|
||||
|
||||
let srv = server::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(|srv| srv.into_future().unwrap());
|
||||
|
||||
srv.join(client).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recv_connection_header() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, client) = mock::new();
|
||||
|
||||
let req = |id, name, val| {
|
||||
frames::headers(id)
|
||||
.request("GET", "https://example.com/")
|
||||
.field(name, val)
|
||||
.eos()
|
||||
};
|
||||
|
||||
let client = client
|
||||
.assert_server_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.send_frame(req(1, "connection", "foo"))
|
||||
.send_frame(req(3, "keep-alive", "5"))
|
||||
.send_frame(req(5, "proxy-connection", "bar"))
|
||||
.send_frame(req(7, "transfer-encoding", "chunked"))
|
||||
.send_frame(req(9, "upgrade", "HTTP/2.0"))
|
||||
.recv_frame(frames::reset(1).protocol_error())
|
||||
.recv_frame(frames::reset(3).protocol_error())
|
||||
.recv_frame(frames::reset(5).protocol_error())
|
||||
.recv_frame(frames::reset(7).protocol_error())
|
||||
.recv_frame(frames::reset(9).protocol_error())
|
||||
.close();
|
||||
|
||||
let srv = server::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(|srv| srv.into_future().unwrap());
|
||||
|
||||
srv.join(client).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sends_reset_cancel_when_req_body_is_dropped() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, client) = mock::new();
|
||||
|
||||
let client = client
|
||||
.assert_server_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.send_frame(
|
||||
frames::headers(1)
|
||||
.request("POST", "https://example.com/")
|
||||
)
|
||||
.recv_frame(frames::headers(1).response(200).eos())
|
||||
.recv_frame(frames::reset(1).cancel())
|
||||
.close();
|
||||
|
||||
let srv = server::handshake(io).expect("handshake").and_then(|srv| {
|
||||
srv.into_future().unwrap().and_then(|(reqstream, srv)| {
|
||||
let (req, mut stream) = reqstream.unwrap();
|
||||
|
||||
assert_eq!(req.method(), &http::Method::POST);
|
||||
|
||||
let rsp = http::Response::builder().status(200).body(()).unwrap();
|
||||
stream.send_response(rsp, true).unwrap();
|
||||
|
||||
srv.into_future().unwrap()
|
||||
})
|
||||
});
|
||||
|
||||
srv.join(client).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn abrupt_shutdown() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, client) = mock::new();
|
||||
|
||||
let client = client
|
||||
.assert_server_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.send_frame(
|
||||
frames::headers(1)
|
||||
.request("POST", "https://example.com/")
|
||||
)
|
||||
.recv_frame(frames::go_away(1))
|
||||
.close();
|
||||
|
||||
let srv = server::handshake(io).expect("handshake").and_then(|srv| {
|
||||
srv.into_future().unwrap().and_then(|(_, mut srv)| {
|
||||
srv.abrupt_shutdown(Reason::NO_ERROR);
|
||||
srv.into_future().unwrap()
|
||||
})
|
||||
});
|
||||
|
||||
srv.join(client).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn graceful_shutdown() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, client) = mock::new();
|
||||
|
||||
let client = client
|
||||
.assert_server_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.send_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://example.com/")
|
||||
.eos(),
|
||||
)
|
||||
// 2^31 - 1 = 2147483647
|
||||
// Note: not using a constant in the library because library devs
|
||||
// can be unsmart.
|
||||
.recv_frame(frames::go_away(2147483647))
|
||||
.recv_frame(frames::ping(frame::Ping::SHUTDOWN))
|
||||
.recv_frame(frames::headers(1).response(200).eos())
|
||||
// Pretend this stream was sent while the GOAWAY was in flight
|
||||
.send_frame(
|
||||
frames::headers(3)
|
||||
.request("POST", "https://example.com/"),
|
||||
)
|
||||
.send_frame(frames::ping(frame::Ping::SHUTDOWN).pong())
|
||||
.recv_frame(frames::go_away(3))
|
||||
// streams sent after GOAWAY receive no response
|
||||
.send_frame(
|
||||
frames::headers(7)
|
||||
.request("GET", "https://example.com/"),
|
||||
)
|
||||
.send_frame(frames::data(7, "").eos())
|
||||
.send_frame(frames::data(3, "").eos())
|
||||
.recv_frame(frames::headers(3).response(200).eos())
|
||||
.close(); //TODO: closed()?
|
||||
|
||||
let srv = server::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(|srv| {
|
||||
srv.into_future().unwrap()
|
||||
})
|
||||
.and_then(|(reqstream, mut srv)| {
|
||||
let (req, mut stream) = reqstream.unwrap();
|
||||
|
||||
assert_eq!(req.method(), &http::Method::GET);
|
||||
|
||||
srv.graceful_shutdown();
|
||||
|
||||
let rsp = http::Response::builder()
|
||||
.status(200)
|
||||
.body(())
|
||||
.unwrap();
|
||||
stream.send_response(rsp, true).unwrap();
|
||||
|
||||
srv.into_future().unwrap()
|
||||
})
|
||||
.and_then(|(reqstream, srv)| {
|
||||
let (req, mut stream) = reqstream.unwrap();
|
||||
assert_eq!(req.method(), &http::Method::POST);
|
||||
let body = req.into_parts().1;
|
||||
|
||||
let body = body.concat2().and_then(move |buf| {
|
||||
assert!(buf.is_empty());
|
||||
|
||||
let rsp = http::Response::builder()
|
||||
.status(200)
|
||||
.body(())
|
||||
.unwrap();
|
||||
stream.send_response(rsp, true).unwrap();
|
||||
Ok(())
|
||||
});
|
||||
|
||||
srv.into_future()
|
||||
.map(|(req, _srv)| {
|
||||
assert!(req.is_none(), "unexpected request");
|
||||
})
|
||||
.drive(body)
|
||||
.and_then(|(srv, ())| {
|
||||
srv.expect("srv")
|
||||
})
|
||||
});
|
||||
|
||||
srv.join(client).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sends_reset_cancel_when_res_body_is_dropped() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, client) = mock::new();
|
||||
|
||||
let client = client
|
||||
.assert_server_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.send_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://example.com/")
|
||||
.eos()
|
||||
)
|
||||
.recv_frame(frames::headers(1).response(200))
|
||||
.recv_frame(frames::reset(1).cancel())
|
||||
.send_frame(
|
||||
frames::headers(3)
|
||||
.request("GET", "https://example.com/")
|
||||
.eos()
|
||||
)
|
||||
.recv_frame(frames::headers(3).response(200))
|
||||
.recv_frame(frames::data(3, vec![0; 10]))
|
||||
.recv_frame(frames::reset(3).cancel())
|
||||
.close();
|
||||
|
||||
let srv = server::handshake(io).expect("handshake").and_then(|srv| {
|
||||
srv.into_future().unwrap().and_then(|(reqstream, srv)| {
|
||||
let (req, mut stream) = reqstream.unwrap();
|
||||
|
||||
assert_eq!(req.method(), &http::Method::GET);
|
||||
|
||||
let rsp = http::Response::builder()
|
||||
.status(200)
|
||||
.body(())
|
||||
.unwrap();
|
||||
stream.send_response(rsp, false).unwrap();
|
||||
// SendStream dropped
|
||||
|
||||
srv.into_future().unwrap()
|
||||
}).and_then(|(reqstream, srv)| {
|
||||
let (_req, mut stream) = reqstream.unwrap();
|
||||
|
||||
let rsp = http::Response::builder()
|
||||
.status(200)
|
||||
.body(())
|
||||
.unwrap();
|
||||
let mut tx = stream.send_response(rsp, false).unwrap();
|
||||
tx.send_data(vec![0; 10].into(), false).unwrap();
|
||||
// no send_data with eos
|
||||
|
||||
srv.into_future().unwrap()
|
||||
})
|
||||
});
|
||||
|
||||
srv.join(client).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn too_big_headers_sends_431() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, client) = mock::new();
|
||||
|
||||
let client = client
|
||||
.assert_server_handshake()
|
||||
.unwrap()
|
||||
.recv_custom_settings(
|
||||
frames::settings()
|
||||
.max_header_list_size(10)
|
||||
)
|
||||
.send_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://example.com/")
|
||||
.field("some-header", "some-value")
|
||||
.eos()
|
||||
)
|
||||
.recv_frame(frames::headers(1).response(431).eos())
|
||||
.idle_ms(10)
|
||||
.close();
|
||||
|
||||
let srv = server::Builder::new()
|
||||
.max_header_list_size(10)
|
||||
.handshake::<_, Bytes>(io)
|
||||
.expect("handshake")
|
||||
.and_then(|srv| {
|
||||
srv.into_future()
|
||||
.expect("server")
|
||||
.map(|(req, _)| {
|
||||
assert!(req.is_none(), "req is {:?}", req);
|
||||
})
|
||||
});
|
||||
|
||||
srv.join(client).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn too_big_headers_sends_reset_after_431_if_not_eos() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, client) = mock::new();
|
||||
|
||||
let client = client
|
||||
.assert_server_handshake()
|
||||
.unwrap()
|
||||
.recv_custom_settings(
|
||||
frames::settings()
|
||||
.max_header_list_size(10)
|
||||
)
|
||||
.send_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://example.com/")
|
||||
.field("some-header", "some-value")
|
||||
)
|
||||
.recv_frame(frames::headers(1).response(431).eos())
|
||||
.recv_frame(frames::reset(1).refused())
|
||||
.close();
|
||||
|
||||
let srv = server::Builder::new()
|
||||
.max_header_list_size(10)
|
||||
.handshake::<_, Bytes>(io)
|
||||
.expect("handshake")
|
||||
.and_then(|srv| {
|
||||
srv.into_future()
|
||||
.expect("server")
|
||||
.map(|(req, _)| {
|
||||
assert!(req.is_none(), "req is {:?}", req);
|
||||
})
|
||||
});
|
||||
|
||||
srv.join(client).wait().expect("wait");
|
||||
}
|
||||
947
tests/h2-tests/tests/stream_states.rs
Normal file
947
tests/h2-tests/tests/stream_states.rs
Normal file
@@ -0,0 +1,947 @@
|
||||
#![deny(warnings)]
|
||||
|
||||
#[macro_use]
|
||||
extern crate log;
|
||||
extern crate h2_support;
|
||||
|
||||
use h2_support::prelude::*;
|
||||
|
||||
#[test]
|
||||
fn send_recv_headers_only() {
|
||||
let _ = env_logger::try_init();
|
||||
|
||||
let mock = mock_io::Builder::new()
|
||||
.handshake()
|
||||
// Write GET /
|
||||
.write(&[
|
||||
0, 0, 0x10, 1, 5, 0, 0, 0, 1, 0x82, 0x87, 0x41, 0x8B, 0x9D, 0x29,
|
||||
0xAC, 0x4B, 0x8F, 0xA8, 0xE9, 0x19, 0x97, 0x21, 0xE9, 0x84,
|
||||
])
|
||||
.write(frames::SETTINGS_ACK)
|
||||
// Read response
|
||||
.read(&[0, 0, 1, 1, 5, 0, 0, 0, 1, 0x89])
|
||||
.build();
|
||||
|
||||
let (mut client, mut h2) = client::handshake(mock).wait().unwrap();
|
||||
|
||||
// Send the request
|
||||
let request = Request::builder()
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
info!("sending request");
|
||||
let (response, _) = client.send_request(request, true).unwrap();
|
||||
|
||||
let resp = h2.run(response).unwrap();
|
||||
assert_eq!(resp.status(), StatusCode::NO_CONTENT);
|
||||
|
||||
h2.wait().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn send_recv_data() {
|
||||
let _ = env_logger::try_init();
|
||||
|
||||
let mock = mock_io::Builder::new()
|
||||
.handshake()
|
||||
.write(&[
|
||||
// POST /
|
||||
0, 0, 16, 1, 4, 0, 0, 0, 1, 131, 135, 65, 139, 157, 41,
|
||||
172, 75, 143, 168, 233, 25, 151, 33, 233, 132,
|
||||
])
|
||||
.write(&[
|
||||
// DATA
|
||||
0, 0, 5, 0, 1, 0, 0, 0, 1, 104, 101, 108, 108, 111,
|
||||
])
|
||||
.write(frames::SETTINGS_ACK)
|
||||
// Read response
|
||||
.read(&[
|
||||
// HEADERS
|
||||
0, 0, 1, 1, 4, 0, 0, 0, 1, 136,
|
||||
// DATA
|
||||
0, 0, 5, 0, 1, 0, 0, 0, 1, 119, 111, 114, 108, 100
|
||||
])
|
||||
.build();
|
||||
|
||||
let (mut client, mut h2) = client::Builder::new().handshake(mock).wait().unwrap();
|
||||
|
||||
let request = Request::builder()
|
||||
.method(Method::POST)
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
info!("sending request");
|
||||
let (response, mut stream) = client.send_request(request, false).unwrap();
|
||||
|
||||
// Reserve send capacity
|
||||
stream.reserve_capacity(5);
|
||||
|
||||
assert_eq!(stream.capacity(), 5);
|
||||
|
||||
// Send the data
|
||||
stream.send_data("hello", true).unwrap();
|
||||
|
||||
// Get the response
|
||||
let resp = h2.run(response).unwrap();
|
||||
assert_eq!(resp.status(), StatusCode::OK);
|
||||
|
||||
// Take the body
|
||||
let (_, body) = resp.into_parts();
|
||||
|
||||
// Wait for all the data frames to be received
|
||||
let bytes = h2.run(body.collect()).unwrap();
|
||||
|
||||
// One byte chunk
|
||||
assert_eq!(1, bytes.len());
|
||||
|
||||
assert_eq!(bytes[0], &b"world"[..]);
|
||||
|
||||
// The H2 connection is closed
|
||||
h2.wait().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn send_headers_recv_data_single_frame() {
|
||||
let _ = env_logger::try_init();
|
||||
|
||||
let mock = mock_io::Builder::new()
|
||||
.handshake()
|
||||
// Write GET /
|
||||
.write(&[
|
||||
0, 0, 16, 1, 5, 0, 0, 0, 1, 130, 135, 65, 139, 157, 41, 172, 75,
|
||||
143, 168, 233, 25, 151, 33, 233, 132
|
||||
])
|
||||
.write(frames::SETTINGS_ACK)
|
||||
// Read response
|
||||
.read(&[
|
||||
0, 0, 1, 1, 4, 0, 0, 0, 1, 136, 0, 0, 5, 0, 0, 0, 0, 0, 1, 104, 101,
|
||||
108, 108, 111, 0, 0, 5, 0, 1, 0, 0, 0, 1, 119, 111, 114, 108, 100,
|
||||
])
|
||||
.build();
|
||||
|
||||
let (mut client, mut h2) = client::handshake(mock).wait().unwrap();
|
||||
|
||||
// Send the request
|
||||
let request = Request::builder()
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
info!("sending request");
|
||||
let (response, _) = client.send_request(request, true).unwrap();
|
||||
|
||||
let resp = h2.run(response).unwrap();
|
||||
assert_eq!(resp.status(), StatusCode::OK);
|
||||
|
||||
// Take the body
|
||||
let (_, body) = resp.into_parts();
|
||||
|
||||
// Wait for all the data frames to be received
|
||||
let bytes = h2.run(body.collect()).unwrap();
|
||||
|
||||
// Two data frames
|
||||
assert_eq!(2, bytes.len());
|
||||
|
||||
assert_eq!(bytes[0], &b"hello"[..]);
|
||||
assert_eq!(bytes[1], &b"world"[..]);
|
||||
|
||||
// The H2 connection is closed
|
||||
h2.wait().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn closed_streams_are_released() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
let h2 = client::handshake(io).unwrap().and_then(|(mut client, h2)| {
|
||||
let request = Request::get("https://example.com/").body(()).unwrap();
|
||||
|
||||
// Send request
|
||||
let (response, _) = client.send_request(request, true).unwrap();
|
||||
h2.drive(response).and_then(move |(_, response)| {
|
||||
assert_eq!(response.status(), StatusCode::NO_CONTENT);
|
||||
|
||||
// There are no active streams
|
||||
assert_eq!(0, client.num_active_streams());
|
||||
|
||||
// The response contains a handle for the body. This keeps the
|
||||
// stream wired.
|
||||
assert_eq!(1, client.num_wired_streams());
|
||||
|
||||
let (_, body) = response.into_parts();
|
||||
assert!(body.is_end_stream());
|
||||
drop(body);
|
||||
|
||||
// The stream state is now free
|
||||
assert_eq!(0, client.num_wired_streams());
|
||||
|
||||
Ok(())
|
||||
})
|
||||
});
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://example.com/")
|
||||
.eos(),
|
||||
)
|
||||
.send_frame(frames::headers(1).response(204).eos())
|
||||
.close();
|
||||
|
||||
let _ = h2.join(srv).wait().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn errors_if_recv_frame_exceeds_max_frame_size() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, mut srv) = mock::new();
|
||||
|
||||
let h2 = client::handshake(io).unwrap().and_then(|(mut client, h2)| {
|
||||
let request = Request::builder()
|
||||
.method(Method::GET)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let req = client
|
||||
.send_request(request, true)
|
||||
.unwrap()
|
||||
.0.unwrap()
|
||||
.and_then(|resp| {
|
||||
assert_eq!(resp.status(), StatusCode::OK);
|
||||
let body = resp.into_parts().1;
|
||||
body.concat2().then(|res| {
|
||||
let err = res.unwrap_err();
|
||||
assert_eq!(err.to_string(), "protocol error: frame with invalid size");
|
||||
Ok::<(), ()>(())
|
||||
})
|
||||
});
|
||||
|
||||
// client should see a conn error
|
||||
let conn = h2.then(|res| {
|
||||
let err = res.unwrap_err();
|
||||
assert_eq!(err.to_string(), "protocol error: frame with invalid size");
|
||||
Ok::<(), ()>(())
|
||||
});
|
||||
conn.unwrap().join(req)
|
||||
});
|
||||
|
||||
// a bad peer
|
||||
srv.codec_mut().set_max_send_frame_size(16_384 * 4);
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.ignore_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://example.com/")
|
||||
.eos(),
|
||||
)
|
||||
.send_frame(frames::headers(1).response(200))
|
||||
.send_frame(frames::data(1, vec![0; 16_385]).eos())
|
||||
.recv_frame(frames::go_away(0).frame_size())
|
||||
.close();
|
||||
|
||||
let _ = h2.join(srv).wait().unwrap();
|
||||
}
|
||||
|
||||
|
||||
#[test]
|
||||
fn configure_max_frame_size() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, mut srv) = mock::new();
|
||||
|
||||
let h2 = client::Builder::new()
|
||||
.max_frame_size(16_384 * 2)
|
||||
.handshake::<_, Bytes>(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, h2)| {
|
||||
let request = Request::builder()
|
||||
.method(Method::GET)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let req = client
|
||||
.send_request(request, true)
|
||||
.unwrap()
|
||||
.0.expect("response")
|
||||
.and_then(|resp| {
|
||||
assert_eq!(resp.status(), StatusCode::OK);
|
||||
let body = resp.into_parts().1;
|
||||
body.concat2().expect("body")
|
||||
})
|
||||
.and_then(|buf| {
|
||||
assert_eq!(buf.len(), 16_385);
|
||||
Ok(())
|
||||
});
|
||||
|
||||
h2.expect("client").join(req)
|
||||
});
|
||||
|
||||
// a good peer
|
||||
srv.codec_mut().set_max_send_frame_size(16_384 * 2);
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.ignore_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://example.com/")
|
||||
.eos(),
|
||||
)
|
||||
.send_frame(frames::headers(1).response(200))
|
||||
.send_frame(frames::data(1, vec![0; 16_385]).eos())
|
||||
.close();
|
||||
|
||||
let _ = h2.join(srv).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recv_goaway_finishes_processed_streams() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://example.com/")
|
||||
.eos(),
|
||||
)
|
||||
.recv_frame(
|
||||
frames::headers(3)
|
||||
.request("GET", "https://example.com/")
|
||||
.eos(),
|
||||
)
|
||||
.send_frame(frames::go_away(1))
|
||||
.send_frame(frames::headers(1).response(200))
|
||||
.send_frame(frames::data(1, vec![0; 16_384]).eos())
|
||||
// expecting a goaway of 0, since server never initiated a stream
|
||||
.recv_frame(frames::go_away(0));
|
||||
//.close();
|
||||
|
||||
let h2 = client::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, h2)| {
|
||||
let request = Request::builder()
|
||||
.method(Method::GET)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let req1 = client.send_request(request, true)
|
||||
.unwrap()
|
||||
.0.expect("response")
|
||||
.and_then(|resp| {
|
||||
assert_eq!(resp.status(), StatusCode::OK);
|
||||
let body = resp.into_parts().1;
|
||||
body.concat2().expect("body")
|
||||
})
|
||||
.and_then(|buf| {
|
||||
assert_eq!(buf.len(), 16_384);
|
||||
Ok(())
|
||||
});
|
||||
|
||||
|
||||
// this request will trigger a goaway
|
||||
let request = Request::builder()
|
||||
.method(Method::GET)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
let req2 = client.send_request(request, true)
|
||||
.unwrap()
|
||||
.0.then(|res| {
|
||||
let err = res.unwrap_err();
|
||||
assert_eq!(err.to_string(), "protocol error: not a result of an error");
|
||||
Ok::<(), ()>(())
|
||||
});
|
||||
|
||||
h2.expect("client").join3(req1, req2)
|
||||
});
|
||||
|
||||
|
||||
h2.join(srv).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recv_next_stream_id_updated_by_malformed_headers() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, client) = mock::new();
|
||||
|
||||
|
||||
let bad_auth = util::byte_str("not:a/good authority");
|
||||
let mut bad_headers: frame::Headers = frames::headers(1)
|
||||
.request("GET", "https://example.com/")
|
||||
.eos()
|
||||
.into();
|
||||
bad_headers.pseudo_mut().authority = Some(bad_auth);
|
||||
|
||||
let client = client
|
||||
.assert_server_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
// bad headers -- should error.
|
||||
.send_frame(bad_headers)
|
||||
.recv_frame(frames::reset(1).protocol_error())
|
||||
// this frame is good, but the stream id should already have been incr'd
|
||||
.send_frame(frames::headers(1)
|
||||
.request("GET", "https://example.com/")
|
||||
.eos())
|
||||
.recv_frame(frames::go_away(1).protocol_error())
|
||||
.close();
|
||||
|
||||
let srv = server::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(|srv| srv.into_future().then(|res| {
|
||||
let (err, _) = res.unwrap_err();
|
||||
assert_eq!(
|
||||
err.to_string(),
|
||||
"protocol error: unspecific protocol error detected"
|
||||
);
|
||||
|
||||
Ok::<(), ()>(())
|
||||
})
|
||||
);
|
||||
|
||||
srv.join(client).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn skipped_stream_ids_are_implicitly_closed() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
let srv = srv
|
||||
.assert_client_handshake()
|
||||
.expect("handshake")
|
||||
.recv_settings()
|
||||
.recv_frame(frames::headers(5)
|
||||
.request("GET", "https://example.com/")
|
||||
.eos(),
|
||||
)
|
||||
// send the response on a lower-numbered stream, which should be
|
||||
// implicitly closed.
|
||||
.send_frame(frames::headers(3).response(200));
|
||||
|
||||
let h2 = client::Builder::new()
|
||||
.initial_stream_id(5)
|
||||
.handshake::<_, Bytes>(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, h2)| {
|
||||
let request = Request::builder()
|
||||
.method(Method::GET)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let req = client.send_request(request, true)
|
||||
.unwrap()
|
||||
.0.then(|res| {
|
||||
let err = res.unwrap_err();
|
||||
assert_eq!(
|
||||
err.to_string(),
|
||||
"protocol error: unspecific protocol error detected");
|
||||
Ok::<(), ()>(())
|
||||
});
|
||||
// client should see a conn error
|
||||
let conn = h2.then(|res| {
|
||||
let err = res.unwrap_err();
|
||||
assert_eq!(
|
||||
err.to_string(),
|
||||
"protocol error: unspecific protocol error detected"
|
||||
);
|
||||
Ok::<(), ()>(())
|
||||
});
|
||||
conn.unwrap().join(req)
|
||||
});
|
||||
|
||||
|
||||
h2.join(srv).wait().expect("wait");
|
||||
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn send_rst_stream_allows_recv_data() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://example.com/")
|
||||
.eos(),
|
||||
)
|
||||
.send_frame(frames::headers(1).response(200))
|
||||
.recv_frame(frames::reset(1).cancel())
|
||||
// sending frames after canceled!
|
||||
// note: sending 2 to cosume 50% of connection window
|
||||
.send_frame(frames::data(1, vec![0; 16_384]))
|
||||
.send_frame(frames::data(1, vec![0; 16_384]).eos())
|
||||
// make sure we automatically free the connection window
|
||||
.recv_frame(frames::window_update(0, 16_384 * 2))
|
||||
// do a pingpong to ensure no other frames were sent
|
||||
.ping_pong([1; 8])
|
||||
.close();
|
||||
|
||||
let client = client::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, conn)| {
|
||||
let request = Request::builder()
|
||||
.method(Method::GET)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let req = client.send_request(request, true)
|
||||
.unwrap()
|
||||
.0.expect("response")
|
||||
.and_then(|resp| {
|
||||
assert_eq!(resp.status(), StatusCode::OK);
|
||||
// drop resp will send a reset
|
||||
Ok(())
|
||||
});
|
||||
|
||||
conn.expect("client")
|
||||
.drive(req)
|
||||
.and_then(|(conn, _)| conn)
|
||||
});
|
||||
|
||||
|
||||
client.join(srv).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn send_rst_stream_allows_recv_trailers() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://example.com/")
|
||||
.eos(),
|
||||
)
|
||||
.send_frame(frames::headers(1).response(200))
|
||||
.send_frame(frames::data(1, vec![0; 16_384]))
|
||||
.recv_frame(frames::reset(1).cancel())
|
||||
// sending frames after canceled!
|
||||
.send_frame(frames::headers(1).field("foo", "bar").eos())
|
||||
// do a pingpong to ensure no other frames were sent
|
||||
.ping_pong([1; 8])
|
||||
.close();
|
||||
|
||||
let client = client::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, conn)| {
|
||||
let request = Request::builder()
|
||||
.method(Method::GET)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let req = client.send_request(request, true)
|
||||
.unwrap()
|
||||
.0.expect("response")
|
||||
.and_then(|resp| {
|
||||
assert_eq!(resp.status(), StatusCode::OK);
|
||||
// drop resp will send a reset
|
||||
Ok(())
|
||||
});
|
||||
|
||||
conn.expect("client")
|
||||
.drive(req)
|
||||
.and_then(|(conn, _)| conn)
|
||||
});
|
||||
|
||||
|
||||
client.join(srv).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rst_stream_expires() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://example.com/")
|
||||
.eos(),
|
||||
)
|
||||
.send_frame(frames::headers(1).response(200))
|
||||
.send_frame(frames::data(1, vec![0; 16_384]))
|
||||
.recv_frame(frames::reset(1).cancel())
|
||||
// wait till after the configured duration
|
||||
.idle_ms(15)
|
||||
.ping_pong([1; 8])
|
||||
// sending frame after canceled!
|
||||
.send_frame(frames::data(1, vec![0; 16_384]).eos())
|
||||
.recv_frame(frames::go_away(0).protocol_error())
|
||||
.close();
|
||||
|
||||
let client = client::Builder::new()
|
||||
.reset_stream_duration(Duration::from_millis(10))
|
||||
.handshake::<_, Bytes>(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, conn)| {
|
||||
let request = Request::builder()
|
||||
.method(Method::GET)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let req = client.send_request(request, true)
|
||||
.unwrap()
|
||||
.0.expect("response")
|
||||
.and_then(|resp| {
|
||||
assert_eq!(resp.status(), StatusCode::OK);
|
||||
// drop resp will send a reset
|
||||
Ok(())
|
||||
})
|
||||
.map_err(|()| -> Error {
|
||||
unreachable!()
|
||||
});
|
||||
|
||||
conn.drive(req)
|
||||
.and_then(|(conn, _)| conn.expect_err("client"))
|
||||
.map(|err| {
|
||||
assert_eq!(
|
||||
err.to_string(),
|
||||
"protocol error: unspecific protocol error detected"
|
||||
);
|
||||
drop(client);
|
||||
})
|
||||
});
|
||||
|
||||
|
||||
client.join(srv).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rst_stream_max() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://example.com/")
|
||||
.eos(),
|
||||
)
|
||||
.recv_frame(
|
||||
frames::headers(3)
|
||||
.request("GET", "https://example.com/")
|
||||
.eos(),
|
||||
)
|
||||
.send_frame(frames::headers(1).response(200))
|
||||
.send_frame(frames::data(1, vec![0; 16]))
|
||||
.send_frame(frames::headers(3).response(200))
|
||||
.send_frame(frames::data(3, vec![0; 16]))
|
||||
.recv_frame(frames::reset(1).cancel())
|
||||
.recv_frame(frames::reset(3).cancel())
|
||||
// sending frame after canceled!
|
||||
// newer streams trump older streams
|
||||
// 3 is still being ignored
|
||||
.send_frame(frames::data(3, vec![0; 16]).eos())
|
||||
// ping pong to be sure of no goaway
|
||||
.ping_pong([1; 8])
|
||||
// 1 has been evicted, will get a goaway
|
||||
.send_frame(frames::data(1, vec![0; 16]).eos())
|
||||
.recv_frame(frames::go_away(0).protocol_error())
|
||||
.close();
|
||||
|
||||
let client = client::Builder::new()
|
||||
.max_concurrent_reset_streams(1)
|
||||
.handshake::<_, Bytes>(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, conn)| {
|
||||
let request = Request::builder()
|
||||
.method(Method::GET)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let req1 = client.send_request(request, true)
|
||||
.unwrap()
|
||||
.0.expect("response1")
|
||||
.and_then(|resp| {
|
||||
assert_eq!(resp.status(), StatusCode::OK);
|
||||
// drop resp will send a reset
|
||||
Ok(())
|
||||
})
|
||||
.map_err(|()| -> Error {
|
||||
unreachable!()
|
||||
});
|
||||
|
||||
let request = Request::builder()
|
||||
.method(Method::GET)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let req2 = client.send_request(request, true)
|
||||
.unwrap()
|
||||
.0.expect("response2")
|
||||
.and_then(|resp| {
|
||||
assert_eq!(resp.status(), StatusCode::OK);
|
||||
// drop resp will send a reset
|
||||
Ok(())
|
||||
})
|
||||
.map_err(|()| -> Error {
|
||||
unreachable!()
|
||||
});
|
||||
|
||||
conn.drive(req1.join(req2))
|
||||
.and_then(|(conn, _)| conn.expect_err("client"))
|
||||
.map(|err| {
|
||||
assert_eq!(
|
||||
err.to_string(),
|
||||
"protocol error: unspecific protocol error detected"
|
||||
);
|
||||
})
|
||||
});
|
||||
|
||||
|
||||
client.join(srv).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reserved_state_recv_window_update() {
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://example.com/")
|
||||
.eos(),
|
||||
)
|
||||
.send_frame(
|
||||
frames::push_promise(1, 2)
|
||||
.request("GET", "https://example.com/push")
|
||||
)
|
||||
// it'd be weird to send a window update on a push promise,
|
||||
// since the client can't send us data, but whatever. The
|
||||
// point is that it's allowed, so we're testing it.
|
||||
.send_frame(frames::window_update(2, 128))
|
||||
.send_frame(frames::headers(1).response(200).eos())
|
||||
// ping pong to ensure no goaway
|
||||
.ping_pong([1; 8])
|
||||
.close();
|
||||
|
||||
let client = client::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, conn)| {
|
||||
let request = Request::builder()
|
||||
.method(Method::GET)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
let req = client.send_request(request, true)
|
||||
.unwrap()
|
||||
.0.expect("response")
|
||||
.and_then(|resp| {
|
||||
assert_eq!(resp.status(), StatusCode::OK);
|
||||
Ok(())
|
||||
});
|
||||
|
||||
|
||||
conn.drive(req)
|
||||
.and_then(|(conn, _)| conn.expect("client"))
|
||||
});
|
||||
|
||||
|
||||
client.join(srv).wait().expect("wait");
|
||||
}
|
||||
/*
|
||||
#[test]
|
||||
fn send_data_after_headers_eos() {
|
||||
let _ = env_logger::try_init();
|
||||
|
||||
let mock = mock_io::Builder::new()
|
||||
.handshake()
|
||||
// Write GET /
|
||||
.write(&[
|
||||
// GET /, no EOS
|
||||
0, 0, 16, 1, 5, 0, 0, 0, 1, 131, 135, 65, 139, 157, 41, 172,
|
||||
75, 143, 168, 233, 25, 151, 33, 233, 132
|
||||
])
|
||||
.build();
|
||||
|
||||
let h2 = client::handshake(mock)
|
||||
.wait().expect("handshake");
|
||||
|
||||
// Send the request
|
||||
let mut request = request::Head::default();
|
||||
request.method = Method::POST;
|
||||
request.uri = "https://http2.akamai.com/".parse().unwrap();
|
||||
|
||||
let id = 1.into();
|
||||
let h2 = h2.send_request(id, request, true).wait().expect("send request");
|
||||
|
||||
let body = "hello";
|
||||
|
||||
// Send the data
|
||||
let err = h2.send_data(id, body.into(), true).wait().unwrap_err();
|
||||
assert_user_err!(err, UnexpectedFrameType);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn exceed_max_streams() {
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
#[test]
|
||||
fn rst_while_closing() {
|
||||
// Test to reproduce panic in issue #246 --- receipt of a RST_STREAM frame
|
||||
// on a stream in the Half Closed (remote) state with a queued EOS causes
|
||||
// a panic.
|
||||
let _ = ::env_logger::try_init();
|
||||
let (io, srv) = mock::new();
|
||||
|
||||
// Rendevous when we've queued a trailers frame
|
||||
let (tx, rx) = ::futures::sync::oneshot::channel();
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("GET", "https://example.com/")
|
||||
)
|
||||
.send_frame(frames::headers(1).response(200))
|
||||
.send_frame(frames::headers(1).eos())
|
||||
// Idling for a moment here is necessary to ensure that the client
|
||||
// enqueues its TRAILERS frame *before* we send the RST_STREAM frame
|
||||
// which causes the panic.
|
||||
.wait_for(rx)
|
||||
// Send the RST_STREAM frame which causes the client to panic.
|
||||
.send_frame(frames::reset(1).cancel())
|
||||
.ping_pong([1; 8])
|
||||
.close();
|
||||
;
|
||||
|
||||
let client = client::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, conn)| {
|
||||
let request = Request::builder()
|
||||
.method(Method::GET)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
// The request should be left streaming.
|
||||
let (resp, stream) = client.send_request(request, false)
|
||||
.expect("send_request");
|
||||
let req = resp
|
||||
// on receipt of an EOS response from the server, transition
|
||||
// the stream Open => Half Closed (remote).
|
||||
.expect("response");
|
||||
conn.drive(req)
|
||||
.map(move |(conn, resp)| {
|
||||
assert_eq!(resp.status(), StatusCode::OK);
|
||||
(conn, stream)
|
||||
})
|
||||
})
|
||||
.and_then(|(conn, mut stream)| {
|
||||
// Enqueue trailers frame.
|
||||
let _ = stream.send_trailers(HeaderMap::new());
|
||||
// Signal the server mock to send RST_FRAME
|
||||
let _ = tx.send(());
|
||||
|
||||
conn
|
||||
// yield once to allow the server mock to be polled
|
||||
// before the conn flushes its buffer
|
||||
.yield_once()
|
||||
.expect("client")
|
||||
});
|
||||
|
||||
|
||||
client.join(srv).wait().expect("wait");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rst_with_buffered_data() {
|
||||
// Data is buffered in `FramedWrite` and the stream is reset locally before
|
||||
// the data is fully flushed. Given that resetting a stream requires
|
||||
// clearing all associated state for that stream, this test ensures that the
|
||||
// buffered up frame is correctly handled.
|
||||
let _ = ::env_logger::try_init();
|
||||
|
||||
// This allows the settings + headers frame through
|
||||
let (io, srv) = mock::new_with_write_capacity(73);
|
||||
|
||||
// Synchronize the client / server on response
|
||||
let (tx, rx) = ::futures::sync::oneshot::channel();
|
||||
|
||||
let srv = srv.assert_client_handshake()
|
||||
.unwrap()
|
||||
.recv_settings()
|
||||
.recv_frame(
|
||||
frames::headers(1)
|
||||
.request("POST", "https://example.com/")
|
||||
)
|
||||
.buffer_bytes(128)
|
||||
.send_frame(frames::headers(1).response(204).eos())
|
||||
.send_frame(frames::reset(1).cancel())
|
||||
.wait_for(rx)
|
||||
.unbounded_bytes()
|
||||
.recv_frame(
|
||||
frames::data(1, vec![0; 16_384]))
|
||||
.close()
|
||||
;
|
||||
|
||||
// A large body
|
||||
let body = vec![0; 2 * frame::DEFAULT_INITIAL_WINDOW_SIZE as usize];
|
||||
|
||||
let client = client::handshake(io)
|
||||
.expect("handshake")
|
||||
.and_then(|(mut client, conn)| {
|
||||
let request = Request::builder()
|
||||
.method(Method::POST)
|
||||
.uri("https://example.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
// Send the request
|
||||
let (resp, mut stream) = client.send_request(request, false)
|
||||
.expect("send_request");
|
||||
|
||||
// Send the data
|
||||
stream.send_data(body.into(), true).unwrap();
|
||||
|
||||
conn.drive({
|
||||
resp.then(|_res| {
|
||||
Ok::<_, ()>(())
|
||||
})
|
||||
})
|
||||
})
|
||||
.and_then(move |(conn, _)| {
|
||||
tx.send(()).unwrap();
|
||||
conn.unwrap()
|
||||
});
|
||||
|
||||
|
||||
client.join(srv).wait().expect("wait");
|
||||
}
|
||||
112
tests/h2-tests/tests/trailers.rs
Normal file
112
tests/h2-tests/tests/trailers.rs
Normal file
@@ -0,0 +1,112 @@
|
||||
#[macro_use]
|
||||
extern crate log;
|
||||
extern crate h2_support;
|
||||
|
||||
use h2_support::prelude::*;
|
||||
|
||||
#[test]
|
||||
fn recv_trailers_only() {
|
||||
let _ = env_logger::try_init();
|
||||
|
||||
let mock = mock_io::Builder::new()
|
||||
.handshake()
|
||||
// Write GET /
|
||||
.write(&[
|
||||
0, 0, 0x10, 1, 5, 0, 0, 0, 1, 0x82, 0x87, 0x41, 0x8B, 0x9D, 0x29,
|
||||
0xAC, 0x4B, 0x8F, 0xA8, 0xE9, 0x19, 0x97, 0x21, 0xE9, 0x84,
|
||||
])
|
||||
.write(frames::SETTINGS_ACK)
|
||||
// Read response
|
||||
.read(&[
|
||||
0, 0, 1, 1, 4, 0, 0, 0, 1, 0x88, 0, 0, 9, 1, 5, 0, 0, 0, 1,
|
||||
0x40, 0x84, 0x42, 0x46, 0x9B, 0x51, 0x82, 0x3F, 0x5F,
|
||||
])
|
||||
.build();
|
||||
|
||||
let (mut client, mut h2) = client::handshake(mock).wait().unwrap();
|
||||
|
||||
// Send the request
|
||||
let request = Request::builder()
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
info!("sending request");
|
||||
let (response, _) = client.send_request(request, true).unwrap();
|
||||
|
||||
let response = h2.run(response).unwrap();
|
||||
assert_eq!(response.status(), StatusCode::OK);
|
||||
|
||||
let (_, mut body) = response.into_parts();
|
||||
|
||||
// Make sure there is no body
|
||||
let chunk = h2.run(poll_fn(|| body.poll())).unwrap();
|
||||
assert!(chunk.is_none());
|
||||
|
||||
let trailers = h2.run(poll_fn(|| body.poll_trailers())).unwrap().unwrap();
|
||||
assert_eq!(1, trailers.len());
|
||||
assert_eq!(trailers["status"], "ok");
|
||||
|
||||
h2.wait().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn send_trailers_immediately() {
|
||||
let _ = env_logger::try_init();
|
||||
|
||||
let mock = mock_io::Builder::new()
|
||||
.handshake()
|
||||
// Write GET /
|
||||
.write(&[
|
||||
0, 0, 0x10, 1, 4, 0, 0, 0, 1, 0x82, 0x87, 0x41, 0x8B, 0x9D, 0x29,
|
||||
0xAC, 0x4B, 0x8F, 0xA8, 0xE9, 0x19, 0x97, 0x21, 0xE9, 0x84, 0, 0,
|
||||
0x0A, 1, 5, 0, 0, 0, 1, 0x40, 0x83, 0xF6, 0x7A, 0x66, 0x84, 0x9C,
|
||||
0xB4, 0x50, 0x7F,
|
||||
])
|
||||
.write(frames::SETTINGS_ACK)
|
||||
// Read response
|
||||
.read(&[
|
||||
0, 0, 1, 1, 4, 0, 0, 0, 1, 0x88, 0, 0, 0x0B, 0, 1, 0, 0, 0, 1,
|
||||
0x68, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x77, 0x6F, 0x72, 0x6C, 0x64,
|
||||
])
|
||||
.build();
|
||||
|
||||
let (mut client, mut h2) = client::handshake(mock).wait().unwrap();
|
||||
|
||||
// Send the request
|
||||
let request = Request::builder()
|
||||
.uri("https://http2.akamai.com/")
|
||||
.body(())
|
||||
.unwrap();
|
||||
|
||||
info!("sending request");
|
||||
let (response, mut stream) = client.send_request(request, false).unwrap();
|
||||
|
||||
let mut trailers = HeaderMap::new();
|
||||
trailers.insert("zomg", "hello".parse().unwrap());
|
||||
|
||||
stream.send_trailers(trailers).unwrap();
|
||||
|
||||
let response = h2.run(response).unwrap();
|
||||
assert_eq!(response.status(), StatusCode::OK);
|
||||
|
||||
let (_, mut body) = response.into_parts();
|
||||
|
||||
// There is a data chunk
|
||||
let chunk = h2.run(poll_fn(|| body.poll())).unwrap();
|
||||
assert!(chunk.is_some());
|
||||
|
||||
let chunk = h2.run(poll_fn(|| body.poll())).unwrap();
|
||||
assert!(chunk.is_none());
|
||||
|
||||
let trailers = h2.run(poll_fn(|| body.poll_trailers())).unwrap();
|
||||
assert!(trailers.is_none());
|
||||
|
||||
h2.wait().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn recv_trailers_without_eos() {
|
||||
// This should be a protocol error?
|
||||
}
|
||||
Reference in New Issue
Block a user