use super::fixtures::{
BackpressureDuplex, DuplexHalf, event_request_id, final_only, heavier_scene, live_progressive,
read_stream_until_done, test_db, tiny_scene,
};
use crate::serve::handle_connection;
use indicatrix_net::{
handshake,
messages::{Cancel, ClientMessage, Done, RenderRequest, StreamEvent, Welcome},
};
use std::io::Cursor;
#[test]
fn cancel_mid_stream_produces_done_cancelled_and_no_further_payload() {
let mut input = Vec::new();
indicatrix_net::messages::write_message(&mut input, &handshake::local_hello()).unwrap();
let request = RenderRequest {
intent: indicatrix_net::messages::RequestIntent::Batch,
request_id: 13,
scene: heavier_scene(),
first_sample: 0,
samples: 64,
stream: live_progressive(0),
};
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::RenderRequest(Box::new(request)),
)
.unwrap();
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::Cancel(Cancel { request_id: 13 }),
)
.unwrap();
let mut duplex = DuplexHalf::new(input);
handle_connection(&mut duplex, 2, &test_db()).unwrap();
let mut out_cursor = Cursor::new(duplex.out);
let _welcome: Welcome = indicatrix_net::messages::read_message(&mut out_cursor).unwrap();
let events = read_stream_until_done(&mut out_cursor);
for (event, _) in &events {
assert_eq!(event_request_id(event), 13);
}
assert!(matches!(
events.last().unwrap().0,
StreamEvent::Done(Done {
cancelled: true,
..
})
));
assert_eq!(
out_cursor.position(),
out_cursor.get_ref().len() as u64,
"no bytes may follow DONE{{cancelled: true, ..}}"
);
}
#[test]
fn a_peer_that_never_drains_ends_the_connection_rather_than_hanging_forever() {
let mut input = Vec::new();
indicatrix_net::messages::write_message(&mut input, &handshake::local_hello()).unwrap();
let request = RenderRequest {
intent: indicatrix_net::messages::RequestIntent::Batch,
request_id: 21,
scene: heavier_scene(),
first_sample: 0,
samples: 64,
stream: live_progressive(0),
};
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::RenderRequest(Box::new(request)),
)
.unwrap();
let mut duplex = BackpressureDuplex::new(input, 8);
let result = handle_connection(&mut duplex, 2, &test_db());
let err = result.expect_err(
"a peer that never drains must end the connection with an error, not hang forever",
);
assert!(
matches!(
err,
indicatrix_net::messages::NetError::Framing(indicatrix_net::framing::FramingError::Io(ref e))
if e.kind() == std::io::ErrorKind::TimedOut
),
"expected the write-timeout error to surface as-is, got {err:?}"
);
}
#[test]
fn a_peer_that_never_drains_ends_the_connection_rather_than_hanging_forever_write_zero() {
let mut input = Vec::new();
indicatrix_net::messages::write_message(&mut input, &handshake::local_hello()).unwrap();
let request = RenderRequest {
intent: indicatrix_net::messages::RequestIntent::Batch,
request_id: 23,
scene: heavier_scene(),
first_sample: 0,
samples: 64,
stream: live_progressive(0),
};
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::RenderRequest(Box::new(request)),
)
.unwrap();
let mut duplex = BackpressureDuplex::new_with_kind(input, 8, std::io::ErrorKind::WriteZero);
let result = handle_connection(&mut duplex, 2, &test_db());
let err = result.expect_err(
"a peer that never drains must end the connection with an error, not hang forever, \
regardless of which io::ErrorKind the write failure carries",
);
assert!(
matches!(
err,
indicatrix_net::messages::NetError::Framing(indicatrix_net::framing::FramingError::Io(ref e))
if e.kind() == std::io::ErrorKind::WriteZero
),
"expected the WriteZero error to surface as-is, got {err:?}"
);
}
#[test]
fn cancel_still_completes_cleanly_against_a_finite_but_sufficient_peer() {
let mut input = Vec::new();
indicatrix_net::messages::write_message(&mut input, &handshake::local_hello()).unwrap();
let request = RenderRequest {
intent: indicatrix_net::messages::RequestIntent::Batch,
request_id: 22,
scene: heavier_scene(),
first_sample: 0,
samples: 64,
stream: live_progressive(0),
};
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::RenderRequest(Box::new(request)),
)
.unwrap();
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::Cancel(Cancel { request_id: 22 }),
)
.unwrap();
let mut duplex = BackpressureDuplex::new(input, 1_000_000);
handle_connection(&mut duplex, 2, &test_db()).unwrap();
let mut out_cursor = Cursor::new(duplex.out);
let _welcome: Welcome = indicatrix_net::messages::read_message(&mut out_cursor).unwrap();
let events = read_stream_until_done(&mut out_cursor);
assert!(matches!(
events.last().unwrap().0,
StreamEvent::Done(Done {
cancelled: true,
..
})
));
}
#[test]
fn stale_request_id_frames_are_identifiable() {
fn run_one_request(request_id: u32) -> Vec<(StreamEvent, Option<Vec<u8>>)> {
let mut input = Vec::new();
indicatrix_net::messages::write_message(&mut input, &handshake::local_hello()).unwrap();
let request = RenderRequest {
intent: indicatrix_net::messages::RequestIntent::Batch,
request_id,
scene: tiny_scene(),
first_sample: 0,
samples: 4,
stream: final_only(0),
};
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::RenderRequest(Box::new(request)),
)
.unwrap();
let mut duplex = DuplexHalf::new(input);
handle_connection(&mut duplex, 1, &test_db()).unwrap();
let mut out_cursor = Cursor::new(duplex.out);
let _welcome: Welcome = indicatrix_net::messages::read_message(&mut out_cursor).unwrap();
read_stream_until_done(&mut out_cursor)
}
let first_events = run_one_request(21);
let second_events = run_one_request(22);
assert_ne!(first_events.len(), 0);
for (event, _) in &first_events {
assert_eq!(event_request_id(event), 21);
assert_ne!(event_request_id(event), 22);
}
assert_ne!(second_events.len(), 0);
for (event, _) in &second_events {
assert_eq!(event_request_id(event), 22);
}
}
#[test]
fn pipelined_render_request_on_one_connection_is_queued_after_an_implicit_cancel() {
let mut input = Vec::new();
indicatrix_net::messages::write_message(&mut input, &handshake::local_hello()).unwrap();
let first_request = RenderRequest {
intent: indicatrix_net::messages::RequestIntent::Batch,
request_id: 41,
scene: heavier_scene(),
first_sample: 0,
samples: 64,
stream: live_progressive(0),
};
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::RenderRequest(Box::new(first_request)),
)
.unwrap();
let second_request = RenderRequest {
intent: indicatrix_net::messages::RequestIntent::Batch,
request_id: 42,
scene: tiny_scene(),
first_sample: 0,
samples: 4,
stream: final_only(0),
};
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::RenderRequest(Box::new(second_request)),
)
.unwrap();
let mut duplex = DuplexHalf::new(input);
handle_connection(&mut duplex, 2, &test_db()).unwrap();
let mut out_cursor = Cursor::new(duplex.out);
let _welcome: Welcome = indicatrix_net::messages::read_message(&mut out_cursor).unwrap();
let first_events = read_stream_until_done(&mut out_cursor);
for (event, _) in &first_events {
assert_eq!(event_request_id(event), 41);
}
assert!(
matches!(
first_events.last().unwrap().0,
StreamEvent::Done(Done {
cancelled: true,
..
})
),
"the superseded request must still get a proper DONE {{ cancelled: true }}, \
not be silently dropped"
);
let second_events = read_stream_until_done(&mut out_cursor);
let frames: Vec<_> = second_events
.iter()
.filter_map(|(e, p)| match e {
StreamEvent::Frame(h) => Some((h, p.as_ref().unwrap())),
_ => None,
})
.collect();
assert_eq!(frames.len(), 1);
let (header, payload) = frames[0];
assert_eq!(header.request_id, 42);
assert_eq!(header.samples, 4);
assert_eq!(
payload.len(),
4 * 4 * indicatrix_net::radiance::BYTES_PER_PIXEL
);
for (event, _) in &second_events {
assert_eq!(event_request_id(event), 42);
}
assert!(matches!(
second_events.last().unwrap().0,
StreamEvent::Done(Done {
cancelled: false,
..
})
));
assert_eq!(
out_cursor.position(),
out_cursor.get_ref().len() as u64,
"no bytes may follow the second request's DONE"
);
}