kyle/boxmaker
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
boxmaker/crates/memoryd/tests/honcho_worker.rs
T

381 lines
13 KiB
Rust
Raw Permalink Blame History

//! The Honcho worker, stepped by hand against the fake Honcho (M5c spec, section 5): a turn sent
//! once as one batch, the speaker's parts then the agent's, neutralised, in parts of 25,000
//! characters, to the `-2` session for a new speaker; an outage waited out with a doubling wait
//! and logged twice in all; a refused send marked failed; a refused key stopping its workspace
//! only; a turn the log no longer holds marked failed; other actions left waiting. The waits and
//! a restart are in `honcho_worker_more.rs`. Do not edit.
#[path = "support/honcho.rs"]
mod honcho;
#[path = "support/logs.rs"]
mod logs;
#[path = "support/tmp.rs"]
mod tmp;
#[path = "support/turns.rs"]
mod turns;
#[path = "support/worker.rs"]
mod worker;
use std::time::Duration;
use bxcore::sanitize::TAGS;
use bxcore::{DataClass, SessionStateReply};
use honcho::{FakeHoncho, Mode, Request};
use logs::assistant;
use memoryd::honcho::ledger::{Item, Record};
use memoryd::honcho::worker::{MAX_BATCH, MAX_PART, Step, parts};
use serde_json::{Value, json};
use turns::{sid, spoken};
use worker::{FAST, Home};
/// The ids fixture 08 answers with.
const IDS: [&str; 2] = ["7HqDWzXcKAdw9tnElCNFg", "mjsyhwuGsXTh1_zG_tWRx"];
fn message_posts(fake: &FakeHoncho) -> Vec<Request> {
fake.requests()
.into_iter()
.filter(|r| r.path.ends_with("/messages"))
.collect()
}
fn turn(text: &str, speaker: &str, reply: &str) -> Vec<bxcore::LogRecord> {
vec![spoken(text, Some(speaker)), assistant(2, Some(reply), &[])]
}
fn meta(session: &str, turn: u64) -> Value {
json!({ "agent": "boxmaker0", "boxmaker_session": session, "turn": turn })
}
fn sent(session: &str, turn: u64) -> impl Fn(&Record) -> bool {
let item = Item::Turn {
session: sid(session),
turn,
};
move |r| matches!(r, Record::Sent { item: i, .. } if *i == item)
}
#[test]
fn the_limits() {
assert_eq!(MAX_PART, 25_000);
assert_eq!(MAX_BATCH, 100);
assert!(parts("").is_empty());
assert_eq!(parts("abc"), vec!["abc".to_string()]);
let long = "é".repeat(MAX_PART);
assert_eq!(parts(&long), vec![long.clone()], "characters, not bytes");
let over = format!("{long}xy");
assert_eq!(parts(&over), vec![long, "xy".to_string()]);
}
#[test]
fn a_turn_is_sent_once_as_one_batch() {
let fake = FakeHoncho::start();
let home = Home::new("worker-once");
home.log("mm-a", &[turn("hello", "kyle", "hi")]);
home.report("mm-a", 1);
let mut w = home.worker(&fake, FAST);
assert_eq!(w.step(), Step::Done);
let posts = message_posts(&fake);
assert_eq!(posts.len(), 1);
assert_eq!(
posts[0].path,
"/v3/workspaces/boxmaker0-trusted/sessions/mm-a/messages"
);
assert_eq!(
posts[0].body,
Some(json!({ "messages": [
{ "content": "hello", "peer_id": "kyle", "metadata": meta("mm-a", 1) },
{ "content": "hi", "peer_id": "boxmaker0", "metadata": meta("mm-a", 1) },
] }))
);
// The session was made first, with both peers.
assert_eq!(fake.requests().len(), 5);
assert!(fake.requests()[3].path.ends_with("/sessions"));
let records = home.records();
assert_eq!(records.len(), 2);
assert!(matches!(&records[1], Record::Sent { ids, .. } if *ids == IDS));
fake.clear();
assert_eq!(w.step(), Step::Idle);
assert!(fake.requests().is_empty());
assert!(home.lines().is_empty(), "{:?}", home.lines());
}
#[test]
fn a_text_over_the_limit_is_sent_in_parts() {
let fake = FakeHoncho::start();
let home = Home::new("worker-parts");
let text = "a".repeat(MAX_PART + 1);
let reply = "é".repeat(MAX_PART);
home.log("mm-a", &[turn(&text, "kyle", &reply)]);
home.report("mm-a", 1);
let mut w = home.worker(&fake, FAST);
assert_eq!(w.step(), Step::Done);
let body = message_posts(&fake)[0].body.clone().unwrap();
let got: Vec<(usize, String)> = body["messages"]
.as_array()
.unwrap()
.iter()
.map(|m| {
(
m["content"].as_str().unwrap().chars().count(),
m["peer_id"].as_str().unwrap().to_string(),
)
})
.collect();
assert_eq!(
got,
vec![
(MAX_PART, "kyle".to_string()),
(1, "kyle".to_string()),
(MAX_PART, "boxmaker0".to_string()),
]
);
}
#[test]
fn both_texts_are_neutralised() {
let fake = FakeHoncho::start();
let home = Home::new("worker-neutral");
let text = format!("a{}b", TAGS[0].text);
let reply = format!("c{}d", TAGS[1].text);
home.log("mm-a", &[turn(&text, "kyle", &reply)]);
home.report("mm-a", 1);
let mut w = home.worker(&fake, FAST);
assert_eq!(w.step(), Step::Done);
let body = message_posts(&fake)[0].body.clone().unwrap();
let contents: Vec<String> = body["messages"]
.as_array()
.unwrap()
.iter()
.map(|m| m["content"].as_str().unwrap().to_string())
.collect();
assert_eq!(contents.len(), 2);
for (content, tag) in contents.iter().zip([TAGS[0].text, TAGS[1].text]) {
assert!(!content.contains(tag));
assert!(content.contains("&lt;"), "not neutralised");
}
}
#[test]
fn a_new_speaker_goes_to_the_next_session() {
let fake = FakeHoncho::start();
let home = Home::new("worker-second");
home.log(
"mm-a",
&[turn("one", "kyle", "a"), turn("two", "ana_b", "b")],
);
home.report("mm-a", 2);
let mut w = home.worker(&fake, FAST);
assert_eq!(w.step(), Step::Done);
assert_eq!(w.step(), Step::Done);
let posts = message_posts(&fake);
assert_eq!(posts.len(), 2);
assert!(posts[0].path.ends_with("/sessions/mm-a/messages"));
assert!(posts[1].path.ends_with("/sessions/mm-a-2/messages"));
let second = fake
.requests()
.into_iter()
.find(|r| r.path.ends_with("/sessions") && r.body.as_ref().unwrap()["id"] == "mm-a-2")
.unwrap();
let peers = second.body.unwrap()["peers"].clone();
assert_eq!(peers["kyle"]["observe_me"], true);
assert_eq!(peers["ana_b"]["observe_me"], true);
assert_eq!(peers["boxmaker0"]["observe_me"], false);
}
#[test]
fn an_outage_is_waited_out_and_logged_twice_in_all() {
let fake = FakeHoncho::start();
let home = Home::new("worker-outage");
home.log("mm-a", &[turn("private-alpha", "kyle", "a")]);
home.log("mm-b", &[turn("private-beta", "kyle", "b")]);
home.report("mm-a", 1);
home.report("mm-b", 1);
let mut w = home.worker(&fake, FAST);
fake.set(Mode::Status(503));
let waits: Vec<Step> = (0..6).map(|_| w.step()).collect();
let ms = |n| Step::Backoff(Duration::from_millis(n));
assert_eq!(waits, vec![ms(1), ms(2), ms(4), ms(8), ms(8), ms(8)]);
assert_eq!(home.lines().len(), 1, "{:?}", home.lines());
fake.set(Mode::Fixtures);
assert_eq!(w.step(), Step::Done);
assert_eq!(w.step(), Step::Done);
let lines = home.lines();
assert_eq!(lines.len(), 2, "{lines:?}");
assert_eq!(
lines[0],
"memoryd: Honcho is unreachable (server, HTTP 503); sends wait and are retried; see docs/runbook.md#honcho-unreachable"
);
assert_eq!(
lines[1],
"memoryd: Honcho answers again; waiting sends go on"
);
// In order: mm-a, then mm-b.
let records = home.records();
let a = records.iter().position(sent("mm-a", 1)).unwrap();
let b = records.iter().position(sent("mm-b", 1)).unwrap();
assert!(a < b);
// A new outage starts from the first wait again.
home.log("mm-c", &[turn("c", "kyle", "c")]);
home.report("mm-c", 1);
fake.set(Mode::Hang);
assert_eq!(w.step(), ms(1));
assert!(home.lines()[2].contains("(timeout)"), "{:?}", home.lines());
}
#[test]
fn a_refused_send_is_marked_failed_and_the_next_goes_on() {
let fake = FakeHoncho::start();
let home = Home::new("worker-refused");
home.log("mm-a", &[turn("private-alpha", "kyle", "a")]);
home.log("mm-b", &[turn("private-beta", "kyle", "b")]);
home.report("mm-a", 1);
home.report("mm-b", 1);
let mut w = home.worker(&fake, FAST);
fake.set(Mode::Status(422));
assert_eq!(w.step(), Step::Done);
let failed = home.records().into_iter().find_map(|r| match r {
Record::Failed {
item, status, kind, ..
} => Some((item, status, kind)),
_ => None,
});
assert_eq!(
failed,
Some((
Item::Turn {
session: sid("mm-a"),
turn: 1
},
Some(422),
"status".to_string()
))
);
let lines = home.lines();
assert_eq!(
lines,
vec![
"memoryd: turn 1 of session mm-a was not sent: Honcho refused the request (status, HTTP 422); it is marked failed; see docs/runbook.md#honcho-send-refused"
.to_string()
]
);
fake.set(Mode::Fixtures);
assert_eq!(w.step(), Step::Done);
assert!(home.records().iter().any(sent("mm-b", 1)));
assert_eq!(w.step(), Step::Idle, "the failed turn is not tried again");
}
#[test]
fn a_refused_key_stops_its_workspace_only() {
let fake = FakeHoncho::start();
let home = Home::new("worker-key");
home.log("mm-a", &[turn("a", "kyle", "a")]);
home.log("mm-b", &[turn("b", "kyle", "b")]);
home.report("mm-a", 1);
*home.answer.lock().unwrap() = Ok(SessionStateReply {
class: DataClass::Private,
untrusted: true,
});
home.report("mm-b", 1);
let mut w = home.worker(&fake, FAST);
fake.set(Mode::Status(401));
assert_eq!(w.step(), Step::Done);
assert_eq!(
home.lines(),
vec![
"memoryd: Honcho refused the key of workspace boxmaker0-trusted (HTTP 401); nothing more is sent to it until memoryd restarts; see docs/runbook.md#honcho-key-refused"
.to_string()
]
);
fake.set(Mode::Fixtures);
fake.clear();
assert_eq!(w.step(), Step::Done);
assert!(home.records().iter().any(sent("mm-b", 1)));
assert!(
fake.requests()
.iter()
.all(|r| !r.path.contains("boxmaker0-trusted"))
);
assert_eq!(w.step(), Step::Idle);
// The trusted turn waits: neither sent nor failed.
let sync = home.sync.lock().unwrap();
assert_eq!(sync.ledger().outbox().len(), 1);
assert_eq!(sync.ledger().counts().failed, 0);
}
#[test]
fn a_turn_the_log_no_longer_holds_is_marked_failed() {
let fake = FakeHoncho::start();
let home = Home::new("worker-gone");
home.log("mm-a", &[turn("a", "kyle", "a")]);
home.report("mm-a", 1);
let path = home.dir.path().join("sessions/mm-a/0.jsonl");
std::fs::write(&path, "not json\n").unwrap();
let mut w = home.worker(&fake, FAST);
assert_eq!(w.step(), Step::Done);
assert!(matches!(
home.records().last(),
Some(Record::Failed { status: None, kind, .. }) if kind == "log"
));
assert_eq!(
home.lines(),
vec![
"memoryd: turn 1 of session mm-a cannot be sent (log); it is marked failed; see docs/runbook.md#session-log-damaged"
.to_string()
]
);
assert!(message_posts(&fake).is_empty());
}
#[test]
fn a_turn_without_its_reply_any_more_is_marked_failed() {
let fake = FakeHoncho::start();
let home = Home::new("worker-noreply");
home.log("mm-a", &[turn("a", "kyle", "a")]);
home.report("mm-a", 1);
// The log now ends in a tool round: the reply is gone.
home.log("mm-a", &[turns::running(Some("kyle"))]);
let mut w = home.worker(&fake, FAST);
assert_eq!(w.step(), Step::Done);
assert!(matches!(
home.records().last(),
Some(Record::Failed { status: None, kind, .. }) if kind == "log"
));
assert!(message_posts(&fake).is_empty());
}
#[test]
fn a_refused_key_ends_an_outage() {
let fake = FakeHoncho::start();
let home = Home::new("worker-key-outage");
home.log("mm-a", &[turn("a", "kyle", "a")]);
home.report("mm-a", 1);
let mut w = home.worker(&fake, FAST);
fake.set(Mode::Status(503));
assert!(matches!(w.step(), Step::Backoff(_)));
fake.set(Mode::Status(403));
assert_eq!(w.step(), Step::Done);
let lines = home.lines();
assert_eq!(lines.len(), 3, "{lines:?}");
assert_eq!(
lines[1],
"memoryd: Honcho answers again; waiting sends go on"
);
assert!(lines[2].ends_with("see docs/runbook.md#honcho-key-refused"));
}
#[test]
fn a_turn_too_long_for_one_batch_is_marked_failed() {
let fake = FakeHoncho::start();
let home = Home::new("worker-long");
let text = "a".repeat(MAX_PART * MAX_BATCH);
home.log("mm-a", &[turn(&text, "kyle", "a")]);
home.report("mm-a", 1);
let mut w = home.worker(&fake, FAST);
assert_eq!(w.step(), Step::Done);
assert!(matches!(
home.records().last(),
Some(Record::Failed { status: None, kind, .. }) if kind == "too-long"
));
assert!(fake.requests().is_empty());
}
Reference in New Issue View Git Blame Copy Permalink