use base64::{Engine as _, engine::general_purpose::STANDARD}; use prometeu_bytecode::SourceSpan; use prometeu_bytecode::assembler::assemble; use prometeu_bytecode::model::{ConstantPoolEntry, 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}; #[path = "support/memcard_process.rs"] mod memcard_process; 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, messages: mpsc::Receiver>, pending: HashMap, 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 = 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, 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 logging_cart(messages_per_frame: usize, message: &str) -> TempDir { let dir = TempDir::new(); let code = assemble(&format!( "{}RET\n", "PUSH_I64 2\nPUSH_I64 41000\nPUSH_CONST 0\nHOSTCALL 0\n".repeat(messages_per_frame) )) .unwrap(); let mut module = TestProgram::single(code, int64_signature(0, 0), 0, 3); module.const_pool = vec![ConstantPoolEntry::String(message.into())]; module.exports = vec![Export { symbol: "main".into(), func_idx: 0 }]; module.syscalls = vec![SyscallDecl { module: "log".into(), name: "write_tag".into(), version: 1, arg_slots: 3, ret_slots: 0, }]; 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":"Native log test", "app_version":"0.1.0","app_mode":"Game","capabilities":["log"]})) .unwrap(), ) .unwrap(); dir } fn initialize_logs(client: &mut Client) { let result = client.ok( "initialize", json!({"protocolVersion":{"major":1,"minor":2}, "requiredCapabilities":["log_read"]}), ); assert_eq!(result["protocolVersion"]["minor"], 2); } fn read_log_page(client: &mut Client, after: Value, limit: u16) -> Value { client.ok("get_logs", json!({"afterSequence":after,"limit":limit})) } fn boot(client: &mut Client, dir: &TempDir) { client.ok("boot", json!({"path":dir.0})); } fn png_bytes(capture: &Value) -> Vec { 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":2})); 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"], 2 ); 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 = 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"]); initialize_logs(&mut c); 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"); assert_eq!( c.call("get_logs", json!({"afterSequence":null,"limit":1}))["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 log_read_requires_explicit_capability_and_minor_two() { for minor in [0, 1, 2] { let mut c = Client::new(&["--stdio"]); assert!(c.hello["capabilities"].as_array().unwrap().contains(&json!("log_read"))); if minor < 2 { assert_eq!( c.call( "initialize", json!({"protocolVersion":{"major":1,"minor":minor}, "requiredCapabilities":["log_read"]}) )["error"]["code"], "incompatible_version" ); } let initialized = c.ok( "initialize", json!({"protocolVersion":{"major":1,"minor":minor}, "requiredCapabilities":[]}), ); assert_eq!(initialized["protocolVersion"]["minor"], minor); assert_eq!( c.call("get_logs", json!({"afterSequence":null,"limit":1}))["error"]["code"], "unsupported_capability" ); assert_eq!(c.ok("get_state", json!({}))["logicalFrameIndex"], 0); c.close(); } } #[test] fn native_log_pages_are_read_only_replayable_and_survive_reset() { let dir = logging_cart(2, "{\"native\":\"é\"}"); let mut c = Client::new(&["--stdio"]); initialize_logs(&mut c); let initial = read_log_page(&mut c, Value::Null, 1); assert_eq!(initial["events"][0]["sequence"], 0); assert_eq!(initial["events"][0]["source"], "pos"); assert_eq!(initial["events"][0]["appId"], Value::Null); assert_eq!(initial["sessionId"], c.hello["sessionId"]); assert_eq!(initial["logEpoch"], 0); assert_eq!(initial["gap"], false); assert_eq!(initial["overflow"], false); boot(&mut c, &dir); c.ok("advance", json!({"frames":2})); let state = c.ok("get_state", json!({})); let fault = c.ok("get_fault", json!({})); let all = read_log_page(&mut c, Value::Null, 1024); let native = all["events"].as_array().unwrap(); let app: Vec<_> = native.iter().filter(|event| event["source"] == "app").collect(); assert_eq!(app.len(), 4); assert!(app.iter().all(|event| event["tag"] == 41000 && event["appId"] == 41 && event["level"] == "info" && event["message"] == "{\"native\":\"é\"}")); let mut cursor = Value::Null; let mut paged = Vec::new(); loop { let page = read_log_page(&mut c, cursor.clone(), 2); assert_eq!(page, read_log_page(&mut c, cursor.clone(), 2)); paged.extend(page["events"].as_array().unwrap().iter().cloned()); cursor = page["nextAfterSequence"].clone(); if cursor == page["newestSequence"] { break; } } assert_eq!(&paged, native); let empty = read_log_page(&mut c, cursor.clone(), 1); assert!(empty["events"].as_array().unwrap().is_empty()); assert_eq!(empty["nextAfterSequence"], cursor); assert_eq!(state, c.ok("get_state", json!({}))); assert_eq!(fault, c.ok("get_fault", json!({}))); assert_eq!( c.call("get_logs", json!({"afterSequence":u64::MAX,"limit":1}))["error"]["code"], "invalid_cursor" ); c.ok("reset", json!({})); let reset = read_log_page(&mut c, Value::Null, 1024); assert_eq!(&reset["events"].as_array().unwrap()[..native.len()], native); let after_reset = read_log_page(&mut c, cursor, 1024); assert!(!after_reset["events"].as_array().unwrap().is_empty()); assert_eq!(after_reset["gap"], false); assert_eq!(after_reset["logEpoch"], 0); assert_eq!(after_reset["sessionId"], all["sessionId"]); c.close(); let mut other = Client::new(&["--stdio"]); initialize_logs(&mut other); let fresh = read_log_page(&mut other, Value::Null, 1); assert_ne!(fresh["sessionId"], all["sessionId"]); assert_eq!(fresh["events"][0]["sequence"], 0); assert_eq!( other.call("get_logs", json!({"afterSequence":all["newestSequence"],"limit":1}))["error"]["code"], "invalid_cursor" ); other.close(); } #[test] fn timely_readers_outlive_ring_capacity_while_stale_cursors_report_gaps() { let dir = logging_cart(10, "retention"); let mut c = Client::new(&["--stdio"]); initialize_logs(&mut c); boot(&mut c, &dir); let mut cursor = Value::Null; let mut count = 0; let mut saw_eviction = false; for _ in 0..5 { assert_eq!(c.ok("advance", json!({"frames":100}))["completed"], 100); loop { let page = read_log_page(&mut c, cursor.clone(), 128); assert_eq!(page["gap"], false); saw_eviction |= page["overflow"] == true; for event in page["events"].as_array().unwrap() { assert_eq!(event["sequence"].as_u64().unwrap(), count); count += 1; } cursor = page["nextAfterSequence"].clone(); if cursor == page["newestSequence"] { break; } } } assert!(count > 4096 && saw_eviction); for stale in [Value::Null, json!(0)] { let page = read_log_page(&mut c, stale, 1); assert_eq!(page["gap"], true); assert_eq!(page["overflow"], true); assert!(page["oldestSequence"].as_u64().unwrap() > 0); assert_eq!(page["events"][0]["sequence"], page["oldestSequence"]); } let empty = read_log_page(&mut c, cursor.clone(), 1); assert_eq!(empty["gap"], false); assert_eq!(empty["overflow"], true); assert_eq!(empty["nextAfterSequence"], cursor); c.close(); } #[test] fn bounded_log_responses_can_be_retried_without_draining() { let dir = logging_cart(10, &"x".repeat(200)); let mut c = Client::new(&["--stdio", "--max-response-bytes", "4096"]); initialize_logs(&mut c); boot(&mut c, &dir); c.ok("advance", json!({"frames":5})); let state = c.ok("get_state", json!({})); let response = c.call("get_logs", json!({"afterSequence":null,"limit":1024})); assert_eq!(response["error"]["code"], "response_too_large"); assert!(response.get("result").is_none()); let first = read_log_page(&mut c, Value::Null, 1); assert_eq!(first["events"][0]["sequence"], 0); assert_eq!(first, read_log_page(&mut c, Value::Null, 1)); assert_eq!(state, c.ok("get_state", json!({}))); c.close(); } #[test] fn log_observation_preserves_existing_guest_length_and_rate_limits() { let dir = logging_cart(12, &"x".repeat(300)); let mut c = Client::new(&["--stdio"]); initialize_logs(&mut c); boot(&mut c, &dir); c.ok("advance", json!({"frames":1})); let page = read_log_page(&mut c, Value::Null, 1024); let app: Vec<_> = page["events"] .as_array() .unwrap() .iter() .filter(|event| event["source"] == "app") .collect(); let messages: Vec<_> = app.iter().filter(|event| event["tag"] == 41000).collect(); assert_eq!(messages.len(), 10); assert!(messages.iter().all(|event| event["message"].as_str().unwrap().len() == 256)); assert_eq!(app.len(), 11); assert!(app.iter().any(|event| event["tag"] == 0 && event["level"] == "warn" && event["message"] == "App exceeded log limit per frame")); assert_eq!(page["gap"], false); assert_eq!(page["overflow"], false); c.close(); } #[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 = serde_json::from_str(include_str!("../../../../devtools/headless-protocol/requests.json")) .unwrap(); for request in valid { validator.validate(&request).unwrap(); } let invalid: Vec = 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(); } #[test] #[ignore = "requires PROMETEU_PROTOCOL_TEST_INSTALL pointing to an isolated installation"] fn packaged_memcard_reopen_first_frame() { let installation = PathBuf::from( std::env::var_os("PROMETEU_PROTOCOL_TEST_INSTALL").expect("set isolated installation path"), ); memcard_process::presentation_reopen(&installation.join("prometeu")); } #[test] #[ignore = "requires PROMETEU_PROTOCOL_TEST_INSTALL pointing to an isolated installation"] fn packaged_native_log_observation() { let installation = PathBuf::from( std::env::var_os("PROMETEU_PROTOCOL_TEST_INSTALL").expect("set isolated installation path"), ); let cwd = TempDir::new(); let dir = logging_cart(1, "installed native log"); let mut c = Client::spawn(&installation.join("prometeu"), &["headless", "--stdio"], Some(&cwd.0)); initialize_logs(&mut c); boot(&mut c, &dir); c.ok("advance", json!({"frames":1})); let page = read_log_page(&mut c, Value::Null, 1024); assert_eq!(page["gap"], false); assert!( page["events"] .as_array() .unwrap() .iter() .any(|event| event["source"] == "app" && event["message"] == "installed native log") ); let installed_schema: Value = serde_json::from_slice( &fs::read(installation.join("headless-protocol/response.schema.json")).unwrap(), ) .unwrap(); jsonschema::validator_for(&installed_schema) .unwrap() .validate(&json!({ "type":"response","sessionId":c.hello["sessionId"],"requestId":"logs","result":page, })) .unwrap(); c.close(); }