112 lines
3.7 KiB
Rust
112 lines
3.7 KiB
Rust
mod common;
|
|
use pdf_presenter::worker::{Reply, Request, read_json, write_json};
|
|
use std::{
|
|
io::Read,
|
|
process::{Command, Stdio},
|
|
};
|
|
#[test]
|
|
fn worker_protocol_loads_renders_and_keeps_previous_document_after_failure() {
|
|
let temp = tempfile::tempdir().unwrap();
|
|
let path = temp.path().join("sample.pdf");
|
|
common::pdf(&path);
|
|
let cache = temp.path().join("cache");
|
|
let mut child = Command::new(env!("CARGO_BIN_EXE_pdf-presenter"))
|
|
.arg("--worker")
|
|
.stdin(Stdio::piped())
|
|
.stdout(Stdio::piped())
|
|
.spawn()
|
|
.unwrap();
|
|
let mut input = child.stdin.take().unwrap();
|
|
let mut output = child.stdout.take().unwrap();
|
|
write_json(
|
|
&mut input,
|
|
&Request::Open {
|
|
epoch: 1,
|
|
path: path.clone(),
|
|
cache: cache.clone(),
|
|
},
|
|
)
|
|
.unwrap();
|
|
let reply: Reply = read_json(&mut output).unwrap();
|
|
assert_eq!(reply.info.unwrap().names.len(), 2);
|
|
write_json(
|
|
&mut input,
|
|
&Request::Open {
|
|
epoch: 2,
|
|
path: temp.path().join("missing.pdf"),
|
|
cache: cache.clone(),
|
|
},
|
|
)
|
|
.unwrap();
|
|
let reply: Reply = read_json(&mut output).unwrap();
|
|
assert!(reply.error.is_some());
|
|
for page in [0, 1] {
|
|
write_json(
|
|
&mut input,
|
|
&Request::Render {
|
|
epoch: 1,
|
|
path: path.clone(),
|
|
cache: cache.clone(),
|
|
page,
|
|
edge: 320,
|
|
},
|
|
)
|
|
.unwrap();
|
|
let reply: Reply = read_json(&mut output).unwrap();
|
|
assert!(reply.error.is_none(), "{:?}", reply.error);
|
|
assert_eq!(reply.frame.unwrap().page, page);
|
|
let mut pixels = vec![0; reply.bytes];
|
|
output.read_exact(&mut pixels).unwrap();
|
|
assert_eq!(pixels.len(), 320 * 180 * 4);
|
|
}
|
|
drop(input);
|
|
assert!(child.wait().unwrap().success());
|
|
}
|
|
#[test]
|
|
fn protocol_rejects_oversized_and_malformed_messages() {
|
|
let mut bytes = std::io::Cursor::new((20_000_000u32).to_le_bytes());
|
|
assert!(read_json::<Request>(&mut bytes).is_err());
|
|
let mut bytes = std::io::Cursor::new([2, 0, 0, 0, b'{', b'?']);
|
|
assert!(read_json::<Request>(&mut bytes).is_err());
|
|
let mut bytes = vec![];
|
|
write_json(&mut bytes, &Request::SleepTest(1)).unwrap();
|
|
assert!(matches!(
|
|
read_json::<Request>(&mut bytes.as_slice()).unwrap(),
|
|
Request::SleepTest(1)
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn supervisor_kills_a_stuck_worker_and_recovers() {
|
|
use std::time::{Duration, Instant};
|
|
let bridge = pdf_presenter::worker::Bridge::with_program(
|
|
Duration::from_millis(300),
|
|
env!("CARGO_BIN_EXE_pdf-presenter").into(),
|
|
);
|
|
let start = Instant::now();
|
|
assert!(bridge.submit(7, 1, Request::SleepTest(5000)));
|
|
let c = bridge.rx.recv_timeout(Duration::from_secs(5)).unwrap();
|
|
assert_eq!((c.generation, c.tag), (7, 1));
|
|
assert!(c.result.err().unwrap().contains("deadline"));
|
|
assert!(start.elapsed() < Duration::from_secs(3));
|
|
assert!(bridge.submit(8, 2, Request::SleepTest(1)));
|
|
let c = bridge.rx.recv_timeout(Duration::from_secs(5)).unwrap();
|
|
assert!(c.result.is_ok());
|
|
assert_eq!((c.generation, c.tag), (8, 2));
|
|
}
|
|
|
|
#[test]
|
|
fn output_diagnostics_are_distinct_from_explicit_blanking() {
|
|
use pdf_presenter::output::Ack;
|
|
let old: Ack =
|
|
serde_json::from_str(r#"{"sequence":0,"page":null,"status":"host restarted","awake":""}"#)
|
|
.unwrap();
|
|
assert!(!old.request_blank);
|
|
let explicit = Ack {
|
|
request_blank: true,
|
|
..Default::default()
|
|
};
|
|
let restored: Ack = serde_json::from_str(&serde_json::to_string(&explicit).unwrap()).unwrap();
|
|
assert!(restored.request_blank);
|
|
}
|