257 lines
7.4 KiB
Rust
257 lines
7.4 KiB
Rust
extern crate h2_test_support;
|
|
use h2_test_support::prelude::*;
|
|
|
|
// In this case, the stream & connection both have capacity, but capacity is not
|
|
// explicitly requested.
|
|
#[test]
|
|
fn send_data_without_requesting_capacity() {
|
|
let _ = ::env_logger::init();
|
|
|
|
let payload = [0; 1024];
|
|
|
|
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, 4, 0, 0, 1, 0, 0, 0, 1,
|
|
])
|
|
.write(&payload[..])
|
|
.write(frames::SETTINGS_ACK)
|
|
// Read response
|
|
.read(&[0, 0, 1, 1, 5, 0, 0, 0, 1, 0x89])
|
|
.build();
|
|
|
|
let mut h2 = Client::handshake(mock)
|
|
.wait().unwrap();
|
|
|
|
let request = Request::builder()
|
|
.method(Method::POST)
|
|
.uri("https://http2.akamai.com/")
|
|
.body(()).unwrap();
|
|
|
|
let mut stream = h2.request(request, false).unwrap();
|
|
|
|
// The capacity should be immediately allocated
|
|
assert_eq!(stream.capacity(), 0);
|
|
|
|
// Send the data
|
|
stream.send_data(payload[..].into(), true).unwrap();
|
|
|
|
// Get the response
|
|
let resp = h2.run(poll_fn(|| stream.poll_response())).unwrap();
|
|
assert_eq!(resp.status(), StatusCode::NO_CONTENT);
|
|
|
|
h2.wait().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn release_capacity_sends_window_update() {
|
|
let _ = ::env_logger::init();
|
|
|
|
let payload = vec![0u8; 65_535];
|
|
|
|
let (io, srv) = mock::new();
|
|
|
|
fn make_request() -> Request<()> {
|
|
Request::builder()
|
|
.method(Method::GET)
|
|
.uri("https://http2.akamai.com/")
|
|
.body(()).unwrap()
|
|
}
|
|
|
|
|
|
/* // End Goal:
|
|
let mock = srv.assert_client_handshake().unwrap()
|
|
// .assert_settings ?
|
|
.and_then(|(_settings, srv)| {
|
|
srv.into_future().unwrap()
|
|
})
|
|
.recv(
|
|
frames::headers(1)
|
|
.request(head.method, head.uri)
|
|
.eos()
|
|
)
|
|
.send(&[
|
|
frames::headers(1)
|
|
.response(200),
|
|
frames::data(1, &payload[0..16_384]),
|
|
frames::data(1, &payload[0..16_384]),
|
|
frames::data(1, &payload[0..16_384]),
|
|
])
|
|
.recv(
|
|
frames::window_update(0, 32_768)
|
|
)
|
|
.recv(
|
|
frames::window_update(1, 32_768)
|
|
)
|
|
*/
|
|
|
|
let mock = srv.assert_client_handshake().unwrap()
|
|
.and_then(|(_settings, srv)| {
|
|
srv.into_future().unwrap()
|
|
})
|
|
.and_then(|(frame, mut srv)| {
|
|
let head = make_request().into_parts().0;
|
|
let expected = frames::headers(1)
|
|
.request(head.method, head.uri)
|
|
.fields(head.headers)
|
|
.eos()
|
|
.into();
|
|
assert_eq!(frame.unwrap(), expected);
|
|
|
|
let res = frames::headers(1)
|
|
.response(200)
|
|
.into();
|
|
srv.send(res).unwrap();
|
|
let data = frames::data(1, &payload[0..16_384]);
|
|
srv.send(data.into()).unwrap();
|
|
let data = frames::data(1, &payload[16_384..16_384 * 2]);
|
|
srv.send(data.into()).unwrap();
|
|
let data = frames::data(1, &payload[16_384 * 2..16_384 * 3]);
|
|
srv.send(data.into()).unwrap();
|
|
srv.into_future().unwrap()
|
|
})
|
|
.and_then(|(frame, srv)| {
|
|
let expected = frames::window_update(0, 32_768);
|
|
assert_eq!(frame.unwrap(), expected.into());
|
|
srv.into_future().unwrap()
|
|
})
|
|
.and_then(|(frame, mut srv)| {
|
|
let expected = frames::window_update(1, 32_768);
|
|
assert_eq!(frame.unwrap(), expected.into());
|
|
|
|
let data = frames::data(1, &payload[16_384 * 3..])
|
|
.eos();
|
|
srv.send(data.into()).unwrap();
|
|
Ok(())
|
|
});
|
|
|
|
let h2 = Client::handshake(io).unwrap()
|
|
.and_then(|mut h2| {
|
|
eprintln!("h2.request");
|
|
let request = make_request();
|
|
|
|
let req = h2.request(request, true).unwrap()
|
|
.unwrap()
|
|
// Get the response
|
|
.and_then(|resp| {
|
|
assert_eq!(resp.status(), StatusCode::OK);
|
|
let body = resp.into_parts().1;
|
|
body.into_future().unwrap()
|
|
})
|
|
|
|
// read some body to use up window size to below half
|
|
.and_then(|(buf, body)| {
|
|
assert_eq!(buf.unwrap().len(), 16_384);
|
|
body.into_future().unwrap()
|
|
})
|
|
.and_then(|(buf, body)| {
|
|
assert_eq!(buf.unwrap().len(), 16_384);
|
|
body.into_future().unwrap()
|
|
})
|
|
.and_then(|(buf, mut body)| {
|
|
let buf = buf.unwrap();
|
|
assert_eq!(buf.len(), 16_384);
|
|
body.release_capacity(buf.len() * 2).unwrap();
|
|
body.into_future().unwrap()
|
|
})
|
|
.and_then(|(buf, _)| {
|
|
assert_eq!(buf.unwrap().len(), 16_383);
|
|
Ok(())
|
|
});
|
|
h2.unwrap().join(req)
|
|
});
|
|
h2.join(mock).wait().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn release_capacity_of_small_amount_does_not_send_window_update() {
|
|
let _ = ::env_logger::init();
|
|
|
|
let payload = [0; 16];
|
|
|
|
let mock = mock_io::Builder::new()
|
|
.handshake()
|
|
.write(&[
|
|
// GET /
|
|
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, 0x88])
|
|
.read(&[
|
|
// DATA
|
|
0, 0, 16, 0, 1, 0, 0, 0, 1,
|
|
])
|
|
.read(&payload[..])
|
|
// write() or WINDOW_UPDATE purposefully excluded
|
|
|
|
// we send a 2nd stream in order to test the window update is
|
|
// is actually written to the socket
|
|
.write(&[
|
|
// GET /
|
|
0, 0, 4, 1, 5, 0, 0, 0, 3, 130, 135, 190, 132,
|
|
])
|
|
.read(&[0, 0, 1, 1, 5, 0, 0, 0, 3, 0x88])
|
|
.build();
|
|
|
|
let mut h2 = Client::handshake(mock)
|
|
.wait().unwrap();
|
|
|
|
let request = Request::builder()
|
|
.method(Method::GET)
|
|
.uri("https://http2.akamai.com/")
|
|
.body(()).unwrap();
|
|
|
|
let mut stream = h2.request(request, true).unwrap();
|
|
|
|
// Get the response
|
|
let resp = h2.run(poll_fn(|| stream.poll_response())).unwrap();
|
|
assert_eq!(resp.status(), StatusCode::OK);
|
|
|
|
let mut body = resp.into_parts().1;
|
|
let buf = h2.run(poll_fn(|| body.poll())).unwrap().unwrap();
|
|
|
|
// release some capacity to send a window_update
|
|
body.release_capacity(buf.len()).unwrap();
|
|
|
|
// send a 2nd stream to force flushing of window updates
|
|
let request = Request::builder()
|
|
.method(Method::GET)
|
|
.uri("https://http2.akamai.com/")
|
|
.body(()).unwrap();
|
|
let mut stream = h2.request(request, true).unwrap();
|
|
let resp = h2.run(poll_fn(|| stream.poll_response())).unwrap();
|
|
assert_eq!(resp.status(), StatusCode::OK);
|
|
|
|
|
|
h2.wait().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
#[ignore]
|
|
fn expand_window_sends_window_update() {
|
|
}
|
|
|
|
#[test]
|
|
#[ignore]
|
|
fn expand_window_calls_are_coalesced() {
|
|
}
|
|
|
|
#[test]
|
|
#[ignore]
|
|
fn recv_data_overflows_window() {
|
|
}
|
|
|
|
#[test]
|
|
#[ignore]
|
|
fn recv_window_update_causes_overflow() {
|
|
// A received window update causes the window to overflow.
|
|
}
|