356 lines
13 KiB
Rust
356 lines
13 KiB
Rust
use super::*;
|
|
use prometeu_test_support::memcard_fixture::{MemcardFixture, memcard_program};
|
|
|
|
fn card(kind: MemcardFixture, version: &str) -> TempDir {
|
|
let dir = TempDir::new();
|
|
fs::write(dir.0.join("program.pbx"), memcard_program(kind)).unwrap();
|
|
fs::write(
|
|
dir.0.join("manifest.json"),
|
|
serde_json::to_vec(&json!({
|
|
"magic":"PMTU","cartridge_version":1,"app_id":4294967295u32,
|
|
"title":"Neutral persistence","app_version":version,"app_mode":"Game",
|
|
"capabilities":["memcard"],"memcard_slots":1
|
|
}))
|
|
.unwrap(),
|
|
)
|
|
.unwrap();
|
|
dir
|
|
}
|
|
fn start_at(binary: &Path) -> Client {
|
|
let mut c = Client::spawn(binary, &["headless", "--stdio"], Some(&std::env::temp_dir()));
|
|
c.ok(
|
|
"initialize",
|
|
json!({"protocolVersion":{"major":1,"minor":1},"requiredCapabilities":["memcard"]}),
|
|
);
|
|
c
|
|
}
|
|
fn start() -> Client {
|
|
start_at(Path::new(env!("CARGO_BIN_EXE_prometeu")))
|
|
}
|
|
fn mount(c: &mut Client, path: &Path, action: &str, access: &str) -> Value {
|
|
c.ok("memcard_mount", json!({"path":path,"action":action,"access":access}))
|
|
}
|
|
fn launch(c: &mut Client, dir: &TempDir, choice: &str) {
|
|
c.ok("boot", json!({"path":dir.0,"memcardChoice":choice}));
|
|
}
|
|
fn oracle(c: &mut Client, expected: i64) {
|
|
let deadline = Instant::now() + Duration::from_secs(5);
|
|
loop {
|
|
let advance = c.ok("advance", json!({"frames":1}));
|
|
assert_eq!(
|
|
advance["stop"],
|
|
"completed",
|
|
"{advance}; state={}; mem={}; fault={}",
|
|
c.ok("get_state", json!({})),
|
|
c.ok("get_memcard_state", json!({})),
|
|
c.ok("get_fault", json!({}))
|
|
);
|
|
let state = c.ok("get_state", json!({}));
|
|
let top = state["stackTop"].as_array().unwrap();
|
|
if top.last().and_then(|v| v["value"].as_str()) == Some(&expected.to_string()) {
|
|
return;
|
|
}
|
|
assert!(Instant::now() < deadline, "oracle {expected} not reached: {state}");
|
|
}
|
|
}
|
|
fn reason(c: &mut Client, command: &str, params: Value, expected: &str) -> Value {
|
|
let error = c.call(command, params)["error"].clone();
|
|
assert_eq!(error["code"], "memcard_error", "{error}");
|
|
assert_eq!(error["details"]["reason"], expected, "{error}");
|
|
error["details"]["state"].clone()
|
|
}
|
|
fn persistence(binary: &Path) {
|
|
let root = TempDir::new();
|
|
let image = root.0.join("save.pmc");
|
|
let write = card(MemcardFixture::Write, "1");
|
|
let mut first = start_at(binary);
|
|
let mounted = mount(&mut first, &image, "create", "read_write");
|
|
assert_eq!(mounted["media"]["cardId"].as_str().unwrap().len(), 32);
|
|
launch(&mut first, &write, "persistent");
|
|
oracle(&mut first, 101);
|
|
let saved = first.ok("get_memcard_state", json!({}));
|
|
assert_eq!(saved["request"]["state"], "success");
|
|
assert_eq!(saved["request"]["retained"], true);
|
|
assert_eq!(saved["dirty"], false);
|
|
assert_eq!(saved["io"]["active"], false);
|
|
first.close();
|
|
let bytes = fs::read(&image).unwrap();
|
|
for version in ["1", "2"] {
|
|
let read = card(MemcardFixture::Read, version);
|
|
let mut next = start_at(binary);
|
|
mount(&mut next, &image, "open", "read_write");
|
|
launch(&mut next, &read, "persistent");
|
|
oracle(&mut next, 201);
|
|
assert_eq!(next.ok("get_state", json!({}))["appId"], 4294967295u32);
|
|
assert_eq!(
|
|
next.ok("get_memcard_state", json!({}))["request"],
|
|
Value::Null,
|
|
"reader must not submit a save"
|
|
);
|
|
next.close();
|
|
assert!(fs::read(&image).unwrap() == bytes, "readback must not rewrite the image");
|
|
}
|
|
let read = card(MemcardFixture::Read, "2");
|
|
let mut memory = start_at(binary);
|
|
mount(&mut memory, &image, "open", "read_only");
|
|
reason(&mut memory, "boot", json!({"path":read.0,"memcardChoice":"persistent"}), "read_only");
|
|
memory.ok("reset", json!({}));
|
|
launch(&mut memory, &read, "memory_existing");
|
|
oracle(&mut memory, 201);
|
|
assert_eq!(memory.ok("get_memcard_state", json!({}))["session"]["mode"], "memory_only");
|
|
memory.close();
|
|
assert!(fs::read(&image).unwrap() == bytes);
|
|
}
|
|
|
|
#[test]
|
|
fn memcard_public_distinct_process_save_readback_and_version_identity() {
|
|
persistence(Path::new(env!("CARGO_BIN_EXE_prometeu")));
|
|
}
|
|
#[test]
|
|
#[ignore = "requires PROMETEU_PROTOCOL_TEST_INSTALL pointing to an extracted dist archive"]
|
|
fn packaged_memcard_process_persistence() {
|
|
let installation = PathBuf::from(
|
|
std::env::var_os("PROMETEU_PROTOCOL_TEST_INSTALL").expect("extracted distribution"),
|
|
);
|
|
persistence(&installation.join("prometeu"));
|
|
}
|
|
#[test]
|
|
fn memcard_dirty_refusal_retains_channel_and_explicit_ram_has_no_save() {
|
|
let dirty = card(MemcardFixture::Dirty, "1");
|
|
let mut c = start();
|
|
launch(&mut c, &dirty, "memory_fresh");
|
|
oracle(&mut c, 301);
|
|
for command in ["shutdown", "reset"] {
|
|
let state = reason(&mut c, command, json!({}), "unsaved_changes");
|
|
assert_eq!(state["dirty"], true);
|
|
assert_eq!(state["session"]["resident"], true);
|
|
assert_eq!(c.ok("get_state", json!({}))["appId"], 4294967295u32);
|
|
}
|
|
let reset = c.ok("reset", json!({"discardUnsaved":true,"pendingWrites":"cancel"}));
|
|
assert_eq!(reset["memcard"]["dirty"], false);
|
|
let write = card(MemcardFixture::Write, "1");
|
|
launch(&mut c, &write, "memory_fresh");
|
|
oracle(&mut c, 104);
|
|
let state = c.ok("get_memcard_state", json!({}));
|
|
assert_eq!(state["request"]["state"], "memory_only");
|
|
assert_eq!(state["dirty"], true);
|
|
assert_eq!(state["io"]["active"], false);
|
|
assert_eq!(state["media"]["path"], Value::Null);
|
|
c.ok("shutdown", json!({"discardUnsaved":true}));
|
|
c.wait_exit();
|
|
}
|
|
#[test]
|
|
fn memcard_media_errors_and_negotiation_never_select_a_fallback() {
|
|
let root = TempDir::new();
|
|
let missing = root.0.join("missing.pmc");
|
|
let mut old = Client::new(&["--stdio"]);
|
|
old.initialize();
|
|
assert_eq!(
|
|
old.call("memcard_mount", json!({"path":missing,"action":"create","access":"read_write"}))
|
|
["error"]["code"],
|
|
"unsupported_capability"
|
|
);
|
|
assert!(!missing.exists());
|
|
old.close();
|
|
let mut c = Client::new(&["--stdio"]);
|
|
assert_eq!(
|
|
c.call(
|
|
"initialize",
|
|
json!({"protocolVersion":{"major":1,"minor":0},"requiredCapabilities":["memcard"]})
|
|
)["error"]["code"],
|
|
"incompatible_version"
|
|
);
|
|
c.ok(
|
|
"initialize",
|
|
json!({"protocolVersion":{"major":1,"minor":1},"requiredCapabilities":["memcard"]}),
|
|
);
|
|
reason(
|
|
&mut c,
|
|
"memcard_mount",
|
|
json!({"path":missing,"action":"open","access":"read_write"}),
|
|
"unavailable",
|
|
);
|
|
assert!(!missing.exists());
|
|
let cart = card(MemcardFixture::Write, "1");
|
|
reason(&mut c, "boot", json!({"path":cart.0}), "choice_required");
|
|
assert_eq!(c.ok("get_state", json!({}))["logicalFrameIndex"], 0);
|
|
c.ok("reset", json!({}));
|
|
let corrupt = root.0.join("corrupt.pmc");
|
|
let mut bytes = vec![0; 5_259_264];
|
|
bytes[..8].copy_from_slice(b"PMCARD1\0");
|
|
bytes[8] = 1;
|
|
fs::write(&corrupt, &bytes).unwrap();
|
|
reason(
|
|
&mut c,
|
|
"memcard_mount",
|
|
json!({"path":corrupt,"action":"open","access":"read_write"}),
|
|
"corrupt",
|
|
);
|
|
assert!(fs::read(&corrupt).unwrap() == bytes);
|
|
assert_eq!(c.ok("get_memcard_state", json!({}))["session"]["mode"], Value::Null);
|
|
c.close();
|
|
}
|
|
#[cfg(unix)]
|
|
#[test]
|
|
fn memcard_process_ownership_covers_aliases_readers_and_release() {
|
|
let root = TempDir::new();
|
|
let image = root.0.join("save.pmc");
|
|
let hard = root.0.join("hard.pmc");
|
|
let sym = root.0.join("sym.pmc");
|
|
let mut owner = start();
|
|
mount(&mut owner, &image, "create", "read_write");
|
|
fs::hard_link(&image, &hard).unwrap();
|
|
std::os::unix::fs::symlink(&image, &sym).unwrap();
|
|
let bytes = fs::read(&image).unwrap();
|
|
let mut contender = start();
|
|
for path in [&image, &hard, &sym] {
|
|
for access in ["read_only", "read_write"] {
|
|
reason(
|
|
&mut contender,
|
|
"memcard_mount",
|
|
json!({"path":path,"action":"open","access":access}),
|
|
"busy",
|
|
);
|
|
}
|
|
}
|
|
reason(
|
|
&mut contender,
|
|
"memcard_mount",
|
|
json!({"path":image,"action":"create","access":"read_write"}),
|
|
"already_exists",
|
|
);
|
|
assert!(fs::read(&image).unwrap() == bytes);
|
|
owner.ok("memcard_unmount", json!({}));
|
|
mount(&mut contender, &image, "open", "read_only");
|
|
reason(
|
|
&mut owner,
|
|
"memcard_mount",
|
|
json!({"path":image,"action":"open","access":"read_only"}),
|
|
"busy",
|
|
);
|
|
contender.close();
|
|
mount(&mut owner, &image, "open", "read_write");
|
|
owner.close();
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
#[test]
|
|
fn memcard_creation_race_and_process_death_release_real_ownership() {
|
|
let root = TempDir::new();
|
|
let image = root.0.join("race.pmc");
|
|
// Kill the actual storage-owning process rather than its dispatcher parent.
|
|
let mut a = Client::new(&["--stdio"]);
|
|
let mut b = Client::new(&["--stdio"]);
|
|
for c in [&mut a, &mut b] {
|
|
c.ok(
|
|
"initialize",
|
|
json!({"protocolVersion":{"major":1,"minor":1},"requiredCapabilities":["memcard"]}),
|
|
);
|
|
}
|
|
let params = json!({"path":image,"action":"create","access":"read_write"});
|
|
let aid = a.send("memcard_mount", params.clone());
|
|
let bid = b.send("memcard_mount", params);
|
|
let ar = a.response(&aid);
|
|
let br = b.response(&bid);
|
|
assert_ne!(
|
|
ar.get("result").is_some(),
|
|
br.get("result").is_some(),
|
|
"exactly one creator must win"
|
|
);
|
|
let (winner, loser, error) =
|
|
if ar.get("result").is_some() { (&mut a, &mut b, br) } else { (&mut b, &mut a, ar) };
|
|
assert_eq!(error["error"]["details"]["reason"], "already_exists");
|
|
let before = fs::read(&image).unwrap();
|
|
winner.child.kill().unwrap();
|
|
winner.child.wait().unwrap();
|
|
mount(loser, &image, "open", "read_write");
|
|
loser.close();
|
|
assert!(fs::read(&image).unwrap() == before);
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
#[test]
|
|
fn memcard_access_denial_is_typed_and_does_not_create_or_modify_media() {
|
|
use std::os::unix::fs::PermissionsExt;
|
|
let root = TempDir::new();
|
|
let image = root.0.join("denied.pmc");
|
|
let mut creator = start();
|
|
mount(&mut creator, &image, "create", "read_write");
|
|
creator.close();
|
|
let before = fs::read(&image).unwrap();
|
|
fs::set_permissions(&image, fs::Permissions::from_mode(0o0)).unwrap();
|
|
let mut c = start();
|
|
reason(
|
|
&mut c,
|
|
"memcard_mount",
|
|
json!({"path":image,"action":"open","access":"read_write"}),
|
|
"access_denied",
|
|
);
|
|
c.close();
|
|
fs::set_permissions(&image, fs::Permissions::from_mode(0o600)).unwrap();
|
|
assert!(fs::read(&image).unwrap() == before);
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
#[test]
|
|
fn desktop_dispatch_forwards_explicit_media_without_interpreting_player_policy() {
|
|
use std::os::unix::fs::PermissionsExt;
|
|
let installation = TempDir::new();
|
|
let dispatcher = installation.0.join("prometeu");
|
|
fs::copy(env!("CARGO_BIN_EXE_prometeu"), &dispatcher).unwrap();
|
|
let runtime = installation.0.join("prometeu-runtime");
|
|
fs::write(&runtime, "#!/bin/sh\nprintf '%s\\n' \"$@\"\n").unwrap();
|
|
fs::set_permissions(&runtime, fs::Permissions::from_mode(0o755)).unwrap();
|
|
for command in ["run", "debug"] {
|
|
let output = Command::new(&dispatcher)
|
|
.args([command, "cartridge", "--memcard", "image with spaces.pmc", "--create-memcard"])
|
|
.output()
|
|
.unwrap();
|
|
assert!(output.status.success());
|
|
let actual = String::from_utf8(output.stdout).unwrap();
|
|
let mut expected = vec![format!("--{command}"), "cartridge".into()];
|
|
if command == "debug" {
|
|
expected.extend(["--port".into(), "7777".into()]);
|
|
}
|
|
expected.extend([
|
|
"--memcard".into(),
|
|
"image with spaces.pmc".into(),
|
|
"--create-memcard".into(),
|
|
]);
|
|
assert_eq!(actual.lines().collect::<Vec<_>>(), expected);
|
|
}
|
|
assert!(
|
|
!Command::new(&dispatcher)
|
|
.args(["run", "cartridge", "--create-memcard"])
|
|
.output()
|
|
.unwrap()
|
|
.status
|
|
.success()
|
|
);
|
|
}
|
|
#[test]
|
|
fn memcard_idle_observation_never_advances_guest_counters() {
|
|
let root = TempDir::new();
|
|
let image = root.0.join("save.pmc");
|
|
let cart = card(MemcardFixture::Write, "1");
|
|
let mut c = start();
|
|
mount(&mut c, &image, "create", "read_write");
|
|
launch(&mut c, &cart, "persistent");
|
|
c.ok("advance", json!({"frames":1}));
|
|
let before = c.ok("get_state", json!({}));
|
|
let deadline = Instant::now() + Duration::from_secs(3);
|
|
loop {
|
|
let state = c.ok("get_memcard_state", json!({}));
|
|
if !state["io"]["active"].as_bool().unwrap() {
|
|
assert_eq!(state["request"]["state"], "success");
|
|
break;
|
|
}
|
|
assert!(Instant::now() < deadline);
|
|
}
|
|
let after = c.ok("get_state", json!({}));
|
|
for field in ["pc", "logicalFrameIndex", "tickIndex", "stackTop"] {
|
|
assert_eq!(before[field], after[field], "{field}");
|
|
}
|
|
c.close();
|
|
}
|