Files
prometeu-runtime/crates/tools/prometeu-cli/tests/automation_process.rs
T

616 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::{BytecodeModule, DebugInfo, Export, FunctionMeta, SyscallDecl};
use prometeu_host_headless::{AdvanceFramesStop, HeadlessHost};
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 = BytecodeModule {
version: 0,
const_pool: vec![],
functions: vec![FunctionMeta {
code_offset: 0,
code_len: code.len() as u32,
param_slots: 0,
local_slots: 0,
return_slots: 0,
max_stack_slots: 8,
}],
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\nFRAME_SYNC\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\nFRAME_SYNC\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\nFRAME_SYNC\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\nFRAME_SYNC\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\nFRAME_SYNC\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();
}