114 lines
3.4 KiB
Rust
114 lines
3.4 KiB
Rust
//! The eight memory messages against byte-exact fixtures, each refusing an unknown key (M5a spec,
|
|
//! section 7). Do not edit these or the fixtures.
|
|
|
|
use proto::{
|
|
CallId, DataClass, Empty, Envelope, MemoryAdmin, MemoryAdminReply, MemoryBlockReply,
|
|
MemoryCall, MemoryCommand, Message, Reindexed, SessionId, SessionUpdated, ToolRequest,
|
|
};
|
|
|
|
const SESSION: &str = "mm-r0000000000000000000000001";
|
|
|
|
fn fixture(name: &str) -> String {
|
|
let path = format!("{}/tests/fixtures/wire/{name}", env!("CARGO_MANIFEST_DIR"));
|
|
let text = std::fs::read_to_string(&path).unwrap_or_else(|e| panic!("{path}: {e}"));
|
|
text.trim_end_matches('\n').to_string()
|
|
}
|
|
|
|
/// The fixture must decode to `msg`, `msg` must encode to exactly the fixture's bytes, and the
|
|
/// body must refuse an extra key.
|
|
fn check(name: &str, id: u64, msg: Message) {
|
|
let want = Envelope {
|
|
v: 1,
|
|
id,
|
|
r#final: true,
|
|
msg,
|
|
};
|
|
let text = fixture(name);
|
|
let got: Envelope = serde_json::from_str(&text).unwrap_or_else(|e| panic!("{name}: {e}"));
|
|
assert_eq!(got, want, "{name}: decoded value");
|
|
assert_eq!(
|
|
serde_json::to_string(&want).unwrap(),
|
|
text,
|
|
"{name}: encoded bytes"
|
|
);
|
|
let extra = text.replacen("\"body\":{", "\"body\":{\"extra\":1,", 1);
|
|
assert!(
|
|
serde_json::from_str::<Envelope>(&extra).is_err(),
|
|
"{name}: an unknown key is refused"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_eight_messages() {
|
|
check("memory_block.json", 1, Message::MemoryBlock(Empty {}));
|
|
check(
|
|
"memory_block_reply.json",
|
|
1,
|
|
Message::MemoryBlockReply(MemoryBlockReply {
|
|
text: "# soul.md\nYou are Boxmaker.\n\n# memory.md (0 of 2,200 characters)\n(empty)\n\n# user.md (0 of 1,375 characters)\n(empty)".to_string(),
|
|
}),
|
|
);
|
|
check(
|
|
"session_updated.json",
|
|
1,
|
|
Message::SessionUpdated(SessionUpdated {
|
|
session: SessionId::new(SESSION).unwrap(),
|
|
}),
|
|
);
|
|
check(
|
|
"memory_call.json",
|
|
3,
|
|
Message::MemoryCall(MemoryCall {
|
|
request: ToolRequest {
|
|
session: SessionId::new(SESSION).unwrap(),
|
|
call: CallId(3),
|
|
tool: "memory".to_string(),
|
|
arguments: r#"{"action":"note","text":"example.org says March."}"#.to_string(),
|
|
},
|
|
taint: DataClass::Private,
|
|
untrusted: true,
|
|
}),
|
|
);
|
|
check("reindex.json", 1, Message::Reindex(Empty {}));
|
|
check(
|
|
"reindexed.json",
|
|
1,
|
|
Message::Reindexed(Reindexed {
|
|
logs: 42,
|
|
records: 1208,
|
|
notes: 7,
|
|
}),
|
|
);
|
|
check(
|
|
"memory_admin.json",
|
|
1,
|
|
Message::MemoryAdmin(MemoryAdmin {
|
|
command: MemoryCommand::Undo,
|
|
arg: "2026-09-24-0007".to_string(),
|
|
}),
|
|
);
|
|
check(
|
|
"memory_admin_reply.json",
|
|
1,
|
|
Message::MemoryAdminReply(MemoryAdminReply {
|
|
text: "undone: 2026-09-24-0007".to_string(),
|
|
}),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn every_command_has_its_name() {
|
|
for (command, name) in [
|
|
(MemoryCommand::Log, "log"),
|
|
(MemoryCommand::Undo, "undo"),
|
|
(MemoryCommand::Pending, "pending"),
|
|
(MemoryCommand::Accept, "accept"),
|
|
(MemoryCommand::Reject, "reject"),
|
|
] {
|
|
assert_eq!(
|
|
serde_json::to_string(&command).unwrap(),
|
|
format!("\"{name}\"")
|
|
);
|
|
}
|
|
}
|