617 lines
22 KiB
Rust
617 lines
22 KiB
Rust
use base64::{Engine as _, engine::general_purpose::STANDARD};
|
|
use prometeu_bytecode::SourceSpan;
|
|
use prometeu_bytecode::assembler::assemble;
|
|
use prometeu_bytecode::model::{DebugInfo, Export, SyscallDecl};
|
|
use prometeu_bytecode::registry::FunctionDecl;
|
|
use prometeu_host_headless::{AdvanceFramesStop, HeadlessHost};
|
|
use prometeu_test_support::program::{TestProgram, int64_signature};
|
|
use serde_json::{Value, json};
|
|
use std::collections::HashMap;
|
|
use std::fs;
|
|
use std::io::{BufRead, BufReader, Write};
|
|
use std::path::{Path, PathBuf};
|
|
use std::process::{Child, ChildStdin, Command, Stdio};
|
|
use std::sync::{
|
|
atomic::{AtomicU64, Ordering},
|
|
mpsc,
|
|
};
|
|
use std::time::{Duration, Instant};
|
|
|
|
struct TempDir(PathBuf);
|
|
impl TempDir {
|
|
fn new() -> Self {
|
|
static COUNTER: AtomicU64 = AtomicU64::new(0);
|
|
let path = std::env::temp_dir().join(format!(
|
|
"prometeu-protocol-test-{}-{}-{}",
|
|
std::process::id(),
|
|
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos(),
|
|
COUNTER.fetch_add(1, Ordering::Relaxed)
|
|
));
|
|
fs::create_dir(&path).unwrap();
|
|
Self(path)
|
|
}
|
|
}
|
|
impl Drop for TempDir {
|
|
fn drop(&mut self) {
|
|
let _ = fs::remove_dir_all(&self.0);
|
|
}
|
|
}
|
|
|
|
struct Client {
|
|
child: Child,
|
|
input: Option<ChildStdin>,
|
|
messages: mpsc::Receiver<Result<Value, String>>,
|
|
pending: HashMap<String, Value>,
|
|
next: u64,
|
|
hello: Value,
|
|
}
|
|
|
|
impl Client {
|
|
fn new(args: &[&str]) -> Self {
|
|
Self::spawn(Path::new(env!("CARGO_BIN_EXE_prometeu-headless")), args, None)
|
|
}
|
|
|
|
fn spawn(binary: &Path, args: &[&str], cwd: Option<&Path>) -> Self {
|
|
let mut command = Command::new(binary);
|
|
command.args(args).stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::inherit());
|
|
if let Some(cwd) = cwd {
|
|
command.current_dir(cwd);
|
|
}
|
|
let mut child = command.spawn().unwrap();
|
|
let input = child.stdin.take();
|
|
let stdout = child.stdout.take().unwrap();
|
|
let (sender, messages) = mpsc::channel();
|
|
std::thread::spawn(move || {
|
|
for line in BufReader::new(stdout).lines() {
|
|
let value = line.map_err(|e| e.to_string()).and_then(|line| {
|
|
serde_json::from_str(&line)
|
|
.map_err(|e| format!("non-protocol stdout: {e}: {line}"))
|
|
});
|
|
if sender.send(value).is_err() {
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
let mut client =
|
|
Self { child, input, messages, pending: HashMap::new(), next: 0, hello: Value::Null };
|
|
client.hello = client.event();
|
|
assert_eq!(client.hello["type"], "hello");
|
|
client
|
|
}
|
|
|
|
fn event(&self) -> Value {
|
|
let message = self
|
|
.messages
|
|
.recv_timeout(Duration::from_secs(15))
|
|
.expect("protocol reply deadline")
|
|
.unwrap();
|
|
static SCHEMA: std::sync::OnceLock<jsonschema::Validator> = std::sync::OnceLock::new();
|
|
let schema = SCHEMA.get_or_init(|| {
|
|
let value: Value = serde_json::from_str(include_str!(
|
|
"../../../../devtools/headless-protocol/response.schema.json"
|
|
))
|
|
.unwrap();
|
|
jsonschema::validator_for(&value).unwrap()
|
|
});
|
|
if let Err(error) = schema.validate(&message) {
|
|
panic!("server message violates published schema: {error}: {message}");
|
|
}
|
|
message
|
|
}
|
|
|
|
fn raw(&mut self, bytes: &[u8]) {
|
|
self.input.as_mut().unwrap().write_all(bytes).unwrap();
|
|
self.input.as_mut().unwrap().flush().unwrap();
|
|
}
|
|
|
|
fn send(&mut self, command: &str, params: Value) -> String {
|
|
self.next += 1;
|
|
let id = format!("q{}", self.next);
|
|
let mut bytes =
|
|
serde_json::to_vec(&json!({"requestId":id,"command":command,"params":params})).unwrap();
|
|
bytes.push(b'\n');
|
|
self.raw(&bytes);
|
|
id
|
|
}
|
|
|
|
fn response(&mut self, id: &str) -> Value {
|
|
if let Some(value) = self.pending.remove(id) {
|
|
return value;
|
|
}
|
|
loop {
|
|
let message = self.event();
|
|
if message["type"] == "progress" {
|
|
continue;
|
|
}
|
|
let message_id = message["requestId"].as_str().unwrap().to_owned();
|
|
if message_id == id {
|
|
return message;
|
|
}
|
|
self.pending.insert(message_id, message);
|
|
}
|
|
}
|
|
|
|
fn call(&mut self, command: &str, params: Value) -> Value {
|
|
let id = self.send(command, params);
|
|
self.response(&id)
|
|
}
|
|
|
|
fn ok(&mut self, command: &str, params: Value) -> Value {
|
|
let response = self.call(command, params);
|
|
assert!(response.get("error").is_none(), "{response}");
|
|
response["result"].clone()
|
|
}
|
|
|
|
fn initialize(&mut self) {
|
|
self.ok("initialize", json!({"protocolVersion":{"major":1,"minor":0},"requiredCapabilities":["advance","capture","cancel"]}));
|
|
}
|
|
|
|
fn wait_exit(&mut self) {
|
|
let deadline = Instant::now() + Duration::from_secs(5);
|
|
loop {
|
|
if let Some(status) = self.child.try_wait().unwrap() {
|
|
assert!(status.success(), "{status}");
|
|
return;
|
|
}
|
|
assert!(Instant::now() < deadline, "process did not exit");
|
|
std::thread::sleep(Duration::from_millis(5));
|
|
}
|
|
}
|
|
|
|
fn close(&mut self) {
|
|
self.ok("shutdown", json!({}));
|
|
self.input.take();
|
|
self.wait_exit();
|
|
}
|
|
}
|
|
impl Drop for Client {
|
|
fn drop(&mut self) {
|
|
let _ = self.child.kill();
|
|
let _ = self.child.wait();
|
|
}
|
|
}
|
|
|
|
fn cartridge(code: &str, gfx: bool) -> TempDir {
|
|
cartridge_bytes(assemble(code).unwrap(), gfx)
|
|
}
|
|
|
|
fn cartridge_bytes(code: Vec<u8>, gfx: bool) -> TempDir {
|
|
let dir = TempDir::new();
|
|
let module = TestProgram {
|
|
const_pool: vec![],
|
|
functions: vec![FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
code_offset: 0,
|
|
code_len: code.len() as u32,
|
|
local_slots: 0,
|
|
max_stack_slots: 8,
|
|
signature: int64_signature(0, 0),
|
|
captures: vec![],
|
|
name: None,
|
|
}],
|
|
code,
|
|
debug_info: Some(DebugInfo {
|
|
pc_to_span: vec![(0, SourceSpan { file_id: 7, start: 11, end: 15 })],
|
|
function_names: vec![(0, "main".into())],
|
|
}),
|
|
exports: vec![Export { symbol: "main".into(), func_idx: 0 }],
|
|
syscalls: if gfx {
|
|
vec![SyscallDecl {
|
|
module: "gfx2d".into(),
|
|
name: "clear".into(),
|
|
version: 1,
|
|
arg_slots: 1,
|
|
ret_slots: 0,
|
|
}]
|
|
} else {
|
|
vec![]
|
|
},
|
|
};
|
|
fs::write(dir.0.join("program.pbx"), module.serialize()).unwrap();
|
|
fs::write(
|
|
dir.0.join("manifest.json"),
|
|
serde_json::to_vec(&json!({"magic":"PMTU","cartridge_version":1,"app_id":41,
|
|
"title":"Protocol test","app_version":"0.1.0","app_mode":"Game","capabilities":["gfx2d"]}))
|
|
.unwrap(),
|
|
)
|
|
.unwrap();
|
|
dir
|
|
}
|
|
|
|
fn colored_cart() -> TempDir {
|
|
cartridge("PUSH_I64 4278190335\nHOSTCALL 0\nRET\n", true)
|
|
}
|
|
fn boot(client: &mut Client, dir: &TempDir) {
|
|
client.ok("boot", json!({"path":dir.0}));
|
|
}
|
|
fn png_bytes(capture: &Value) -> Vec<u8> {
|
|
let bytes = STANDARD.decode(capture["data"].as_str().unwrap()).unwrap();
|
|
let decoder = png::Decoder::new(std::io::Cursor::new(bytes));
|
|
let mut reader = decoder.read_info().unwrap();
|
|
let mut output = vec![0; reader.output_buffer_size()];
|
|
let info = reader.next_frame(&mut output).unwrap();
|
|
assert_eq!(info.color_type, png::ColorType::Rgba);
|
|
assert_eq!(info.width as u64, capture["width"].as_u64().unwrap());
|
|
assert_eq!(info.height as u64, capture["height"].as_u64().unwrap());
|
|
output.truncate(info.buffer_size());
|
|
output
|
|
}
|
|
|
|
#[test]
|
|
fn handshake_versions_capabilities_and_limits_are_explicit() {
|
|
let mut c = Client::new(&["--stdio"]);
|
|
assert_eq!(c.hello["runtimeVersion"], env!("CARGO_PKG_VERSION"));
|
|
assert_eq!(c.hello["protocolVersion"], json!({"major":1,"minor":0}));
|
|
assert_eq!(
|
|
c.hello["limits"],
|
|
json!({"maxFrames":600,"maxCommandBytes":65536,"maxResponseBytes":33554432,
|
|
"handshakeTimeoutMs":5000,"callTimeoutMs":60000,"shutdownTimeoutMs":5000})
|
|
);
|
|
assert_eq!(c.call("get_state", json!({}))["error"]["code"], "not_initialized");
|
|
assert_eq!(
|
|
c.call(
|
|
"initialize",
|
|
json!({"protocolVersion":{"major":2,"minor":0},"requiredCapabilities":[]})
|
|
)["error"]["code"],
|
|
"incompatible_version"
|
|
);
|
|
assert_eq!(
|
|
c.call(
|
|
"initialize",
|
|
json!({"protocolVersion":{"major":1,"minor":0},"requiredCapabilities":["telepathy"]})
|
|
)["error"]["code"],
|
|
"unsupported_capability"
|
|
);
|
|
assert_eq!(
|
|
c.ok(
|
|
"initialize",
|
|
json!({"protocolVersion":{"major":1,"minor":42},"requiredCapabilities":[]})
|
|
)["protocolVersion"]["minor"],
|
|
0
|
|
);
|
|
assert_eq!(
|
|
c.call(
|
|
"initialize",
|
|
json!({"protocolVersion":{"major":1,"minor":0},"requiredCapabilities":[]})
|
|
)["error"]["code"],
|
|
"already_initialized"
|
|
);
|
|
c.close();
|
|
}
|
|
|
|
#[test]
|
|
fn malformed_fragmented_and_oversized_commands_do_not_desynchronize() {
|
|
let mut c = Client::new(&["--stdio", "--max-command-bytes", "4096"]);
|
|
c.initialize();
|
|
c.raw(b"not json\n");
|
|
assert_eq!(c.event()["error"]["code"], "invalid_request");
|
|
c.raw(&[0xff, b'\n']);
|
|
assert_eq!(c.event()["error"]["code"], "invalid_request");
|
|
let mut huge = vec![b' '; 5000];
|
|
huge.push(b'\n');
|
|
c.raw(&huge);
|
|
assert_eq!(c.event()["error"]["code"], "request_too_large");
|
|
c.raw(b"{\"requestId\":\"fragment\",\"command\":\"get_");
|
|
assert!(c.messages.try_recv().is_err());
|
|
c.raw(b"state\",\"params\":{}}\r\n");
|
|
assert_eq!(c.response("fragment")["result"]["status"], "terminated");
|
|
assert_eq!(c.call("get_state", json!({"typo":1}))["error"]["code"], "invalid_params");
|
|
assert_eq!(c.call("advance", json!({"frames":-1}))["error"]["code"], "invalid_params");
|
|
assert_eq!(c.call("advance", json!({"frames":601}))["error"]["code"], "limit_exceeded");
|
|
assert_eq!(c.call("missing", json!({}))["error"]["code"], "unknown_command");
|
|
c.close();
|
|
}
|
|
|
|
#[test]
|
|
fn lifecycle_and_capture_match_the_in_process_canonical_oracle() {
|
|
let dir = colored_cart();
|
|
let mut c = Client::new(&["--stdio"]);
|
|
c.initialize();
|
|
assert_eq!(c.call("capture", json!({}))["error"]["code"], "no_frame_available");
|
|
boot(&mut c, &dir);
|
|
assert_eq!(c.call("boot", json!({"path":dir.0}))["error"]["code"], "already_booted");
|
|
let initial = c.ok("get_state", json!({}));
|
|
assert_eq!(initial, c.ok("get_state", json!({})), "no background ticks");
|
|
assert_eq!(
|
|
c.ok("advance", json!({"frames":0})),
|
|
json!({"requested":0,"completed":0,"stop":"completed"})
|
|
);
|
|
c.ok("set_input", json!({"right":true,"touch":true,"touchX":123,"touchY":45}));
|
|
c.ok("clear_input", json!({}));
|
|
let outcome = c.ok("advance", json!({"frames":3}));
|
|
assert_eq!(outcome["completed"], 3);
|
|
let capture = c.ok("capture", json!({}));
|
|
let mut host = HeadlessHost::new();
|
|
host.boot(dir.0.to_string_lossy()).unwrap();
|
|
assert_eq!(host.advance_frames(3).unwrap().stop, AdvanceFramesStop::Completed);
|
|
let expected = host.capture_frame().unwrap();
|
|
let pixels: Vec<u8> = expected.frame.pixels.iter().flat_map(|v| v.to_be_bytes()).collect();
|
|
assert_eq!(png_bytes(&capture), pixels);
|
|
assert_eq!(capture["logicalFrameIndex"], expected.logical_frame_index);
|
|
assert_eq!(capture["frameId"], expected.frame.frame_id.get());
|
|
assert_eq!(capture["stridePixels"], expected.frame.stride_pixels);
|
|
assert_eq!(c.ok("get_fault", json!({})), Value::Null);
|
|
c.ok("reset", json!({}));
|
|
assert_eq!(c.call("capture", json!({}))["error"]["code"], "no_frame_available");
|
|
assert_eq!(c.ok("advance", json!({"frames":1}))["stop"], "terminated");
|
|
boot(&mut c, &dir);
|
|
c.ok("advance", json!({"frames":3}));
|
|
assert_eq!(c.ok("capture", json!({})), capture);
|
|
c.close();
|
|
}
|
|
|
|
#[test]
|
|
fn independent_processes_match_pixels_ids_state_and_fault() {
|
|
// Color is selected by the real normalized RIGHT-down intrinsic.
|
|
let mut code = assemble("INTRINSIC 0x210E\n").unwrap();
|
|
let jump = code.len() + 2;
|
|
code.extend(assemble("JMP_IF_FALSE 0\nPUSH_I64 4278190335\nHOSTCALL 0\nRET\n").unwrap());
|
|
let blue = code.len() as u32;
|
|
code[jump..jump + 4].copy_from_slice(&blue.to_le_bytes());
|
|
code.extend(assemble("PUSH_I64 65535\nHOSTCALL 0\nRET\n").unwrap());
|
|
let dir = cartridge_bytes(code, true);
|
|
let run = |c: &mut Client| {
|
|
boot(c, &dir);
|
|
c.ok("set_input", json!({"right":true}));
|
|
c.ok("advance", json!({"frames":12}));
|
|
let held = c.ok("capture", json!({}));
|
|
assert!(png_bytes(&held).as_chunks::<4>().0.iter().all(|p| *p == [255, 0, 0, 255]));
|
|
c.ok("clear_input", json!({}));
|
|
c.ok("advance", json!({"frames":1}));
|
|
let released = c.ok("capture", json!({}));
|
|
assert!(png_bytes(&released).as_chunks::<4>().0.iter().all(|p| *p == [0, 0, 255, 255]));
|
|
(held, released, c.ok("get_state", json!({})), c.ok("get_fault", json!({})))
|
|
};
|
|
let mut first = Client::new(&["--stdio"]);
|
|
first.initialize();
|
|
let expected = run(&mut first);
|
|
first.ok("reset", json!({}));
|
|
assert_eq!(run(&mut first), expected);
|
|
first.close();
|
|
let mut second = Client::new(&["--stdio"]);
|
|
second.initialize();
|
|
assert_eq!(run(&mut second), expected);
|
|
second.close();
|
|
}
|
|
|
|
#[test]
|
|
fn partial_guest_fault_and_host_watchdog_are_distinct_outcomes() {
|
|
let mut code =
|
|
assemble("GET_GLOBAL 0\nPUSH_I32 1\nADD\nSET_GLOBAL 0\nGET_GLOBAL 0\nPUSH_I32 3\nEQ\n")
|
|
.unwrap();
|
|
let jump = code.len() + 2;
|
|
code.extend(assemble("JMP_IF_FALSE 0\nTRAP\n").unwrap());
|
|
let next = code.len() as u32;
|
|
code[jump..jump + 4].copy_from_slice(&next.to_le_bytes());
|
|
code.extend(assemble("PUSH_I64 255\nHOSTCALL 0\nRET\n").unwrap());
|
|
let dir = cartridge_bytes(code, true);
|
|
let mut c = Client::new(&["--stdio"]);
|
|
c.initialize();
|
|
boot(&mut c, &dir);
|
|
let outcome = c.ok("advance", json!({"frames":5}));
|
|
assert_eq!(outcome["completed"], 2);
|
|
assert_eq!(outcome["stop"], "faulted");
|
|
assert_eq!(outcome["fault"], c.ok("get_fault", json!({})));
|
|
c.ok("reset", json!({}));
|
|
let infinite = cartridge("JMP 0\n", false);
|
|
boot(&mut c, &infinite);
|
|
let outcome = c.ok("advance", json!({"frames":5}));
|
|
assert_eq!(outcome["completed"], 0);
|
|
assert_eq!(outcome["stop"], "host_error");
|
|
assert_eq!(outcome["error"]["code"], "watchdog_expired");
|
|
assert_eq!(c.ok("get_fault", json!({})), Value::Null);
|
|
assert_eq!(c.ok("get_state", json!({}))["status"], "paused");
|
|
c.close();
|
|
}
|
|
|
|
#[test]
|
|
fn faults_and_boot_failures_are_structured_not_log_parsing() {
|
|
let dir = cartridge("TRAP\nRET\n", false);
|
|
let mut c = Client::new(&["--stdio"]);
|
|
c.initialize();
|
|
boot(&mut c, &dir);
|
|
let result = c.ok("advance", json!({"frames":5}));
|
|
assert_eq!(result["completed"], 0);
|
|
assert_eq!(result["stop"], "faulted");
|
|
assert_eq!(result["fault"]["kind"], "vm_trap");
|
|
assert!(result["fault"]["trap"]["code"].is_number());
|
|
assert_eq!(c.ok("get_fault", json!({})), result["fault"]);
|
|
assert_eq!(c.ok("get_state", json!({}))["status"], "faulted");
|
|
c.ok("reset", json!({}));
|
|
fs::write(dir.0.join("program.pbx"), b"not PBX").unwrap();
|
|
let response = c.call("boot", json!({"path":dir.0}));
|
|
assert_eq!(response["error"]["code"], "boot_failed");
|
|
assert_eq!(response["error"]["details"]["fault"]["kind"], "vm_init");
|
|
assert!(response["error"]["details"]["fault"]["initError"]["code"].is_string());
|
|
c.close();
|
|
}
|
|
|
|
#[test]
|
|
fn conflicting_work_is_rejected_and_cancellation_reports_partial_progress() {
|
|
let dir = colored_cart();
|
|
let mut c = Client::new(&["--stdio", "--max-frames", "100000"]);
|
|
c.initialize();
|
|
boot(&mut c, &dir);
|
|
let advance = c.send("advance", json!({"frames":100000}));
|
|
assert_eq!(c.event()["type"], "progress");
|
|
assert_eq!(c.call("reset", json!({}))["error"]["code"], "busy");
|
|
c.ok("cancel", json!({"targetRequestId":advance}));
|
|
let response = c.response(&advance);
|
|
let result = &response["result"];
|
|
assert_eq!(result["stop"], "canceled");
|
|
assert!(
|
|
result["completed"].as_u64().unwrap() >= 1
|
|
&& result["completed"].as_u64().unwrap() < 100000
|
|
);
|
|
assert_eq!(c.ok("get_state", json!({}))["logicalFrameIndex"], result["completed"]);
|
|
assert_eq!(
|
|
c.call("cancel", json!({"targetRequestId":advance}))["error"]["code"],
|
|
"not_cancelable"
|
|
);
|
|
c.close();
|
|
}
|
|
|
|
#[test]
|
|
fn shutdown_and_eof_interrupt_active_work_without_resuming_it() {
|
|
let dir = colored_cart();
|
|
for explicit in [true, false] {
|
|
let mut c = Client::new(&["--stdio", "--max-frames", "100000"]);
|
|
c.initialize();
|
|
boot(&mut c, &dir);
|
|
let advance = c.send("advance", json!({"frames":100000}));
|
|
assert_eq!(c.event()["type"], "progress");
|
|
if explicit {
|
|
let shutdown = c.send("shutdown", json!({}));
|
|
assert_eq!(c.response(&advance)["result"]["stop"], "canceled");
|
|
assert_eq!(c.response(&shutdown)["result"]["closed"], true);
|
|
} else {
|
|
c.input.take();
|
|
assert_eq!(c.response(&advance)["result"]["stop"], "canceled");
|
|
}
|
|
c.wait_exit();
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn idle_eof_and_truncated_eof_close_the_process() {
|
|
for suffix in [b"".as_slice(), b"{\"requestId\":\"partial\"".as_slice()] {
|
|
let mut c = Client::new(&["--stdio"]);
|
|
c.raw(suffix);
|
|
c.input.take();
|
|
if !suffix.is_empty() {
|
|
assert_eq!(c.event()["error"]["code"], "invalid_request");
|
|
}
|
|
c.wait_exit();
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn dispatcher_works_from_a_relocated_installation_and_other_cwd() {
|
|
let installation = TempDir::new();
|
|
let cwd = TempDir::new();
|
|
let dispatcher = installation.0.join(if cfg!(windows) { "prometeu.exe" } else { "prometeu" });
|
|
let headless = installation.0.join(if cfg!(windows) {
|
|
"prometeu-headless.exe"
|
|
} else {
|
|
"prometeu-headless"
|
|
});
|
|
fs::copy(env!("CARGO_BIN_EXE_prometeu"), &dispatcher).unwrap();
|
|
fs::copy(env!("CARGO_BIN_EXE_prometeu-headless"), &headless).unwrap();
|
|
let mut c = Client::spawn(
|
|
&dispatcher,
|
|
&[
|
|
"headless",
|
|
"--stdio",
|
|
"--max-frames",
|
|
"17",
|
|
"--max-command-bytes",
|
|
"8192",
|
|
"--max-response-bytes",
|
|
"16384",
|
|
"--handshake-timeout-ms",
|
|
"1234",
|
|
"--call-timeout-ms",
|
|
"2345",
|
|
"--shutdown-timeout-ms",
|
|
"3456",
|
|
],
|
|
Some(&cwd.0),
|
|
);
|
|
assert_eq!(
|
|
c.hello["limits"],
|
|
json!({"maxFrames":17,"maxCommandBytes":8192,"maxResponseBytes":16384,
|
|
"handshakeTimeoutMs":1234,"callTimeoutMs":2345,"shutdownTimeoutMs":3456})
|
|
);
|
|
c.initialize();
|
|
c.close();
|
|
let help = Command::new(&dispatcher).arg("--help").output().unwrap();
|
|
let help = String::from_utf8(help.stdout).unwrap();
|
|
for name in ["run", "debug", "headless"] {
|
|
assert!(help.contains(name));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn missing_binary_and_invalid_cli_limits_fail_explicitly() {
|
|
let installation = TempDir::new();
|
|
let dispatcher = installation.0.join(if cfg!(windows) { "prometeu.exe" } else { "prometeu" });
|
|
fs::copy(env!("CARGO_BIN_EXE_prometeu"), &dispatcher).unwrap();
|
|
let result = Command::new(&dispatcher).args(["headless", "--stdio"]).output().unwrap();
|
|
assert!(!result.status.success());
|
|
assert!(String::from_utf8_lossy(&result.stderr).contains("headless"));
|
|
for args in
|
|
[vec!["--stdio", "--max-frames", "0"], vec!["--stdio", "--max-response-bytes", "1"], vec![]]
|
|
{
|
|
let result =
|
|
Command::new(env!("CARGO_BIN_EXE_prometeu-headless")).args(args).output().unwrap();
|
|
assert!(!result.status.success());
|
|
assert!(result.stdout.is_empty());
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn schemas_and_distributed_request_fixtures_are_consistent() {
|
|
let request: Value = serde_json::from_str(include_str!(
|
|
"../../../../devtools/headless-protocol/request.schema.json"
|
|
))
|
|
.unwrap();
|
|
let response: Value = serde_json::from_str(include_str!(
|
|
"../../../../devtools/headless-protocol/response.schema.json"
|
|
))
|
|
.unwrap();
|
|
jsonschema::meta::validate(&request).unwrap();
|
|
jsonschema::meta::validate(&response).unwrap();
|
|
let validator = jsonschema::validator_for(&request).unwrap();
|
|
let valid: Vec<Value> =
|
|
serde_json::from_str(include_str!("../../../../devtools/headless-protocol/requests.json"))
|
|
.unwrap();
|
|
for request in valid {
|
|
validator.validate(&request).unwrap();
|
|
}
|
|
let invalid: Vec<Value> = serde_json::from_str(include_str!(
|
|
"../../../../devtools/headless-protocol/invalid-requests.json"
|
|
))
|
|
.unwrap();
|
|
let mut c = Client::new(&["--stdio"]);
|
|
c.initialize();
|
|
for request in invalid {
|
|
assert!(!validator.is_valid(&request), "{request}");
|
|
let mut bytes = serde_json::to_vec(&request).unwrap();
|
|
bytes.push(b'\n');
|
|
c.raw(&bytes);
|
|
assert!(c.event().get("error").is_some(), "{request}");
|
|
}
|
|
c.close();
|
|
}
|
|
|
|
#[test]
|
|
#[ignore = "requires PROMETEU_PROTOCOL_TEST_INSTALL pointing to an extracted dist archive"]
|
|
fn packaged_installation_smoke() {
|
|
let installation = PathBuf::from(
|
|
std::env::var_os("PROMETEU_PROTOCOL_TEST_INSTALL")
|
|
.expect("set extracted distribution path"),
|
|
);
|
|
for file in [
|
|
"prometeu",
|
|
"prometeu-runtime",
|
|
"prometeu-headless",
|
|
"headless-protocol/request.schema.json",
|
|
"headless-protocol/response.schema.json",
|
|
"11a-headless-automation-protocol.md",
|
|
] {
|
|
assert!(installation.join(file).is_file(), "missing packaged {file}");
|
|
}
|
|
let cwd = TempDir::new();
|
|
let dir = colored_cart();
|
|
let mut c =
|
|
Client::spawn(&installation.join("prometeu"), &["headless", "--stdio"], Some(&cwd.0));
|
|
assert_eq!(c.hello["runtimeVersion"], env!("CARGO_PKG_VERSION"));
|
|
c.initialize();
|
|
boot(&mut c, &dir);
|
|
c.ok("advance", json!({"frames":3}));
|
|
let capture = c.ok("capture", json!({}));
|
|
assert!(png_bytes(&capture).as_chunks::<4>().0.iter().all(|p| *p == [255, 0, 0, 255]));
|
|
c.input.take();
|
|
c.wait_exit();
|
|
}
|