diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/federation/corpus.rs | 238 | ||||
| -rw-r--r-- | src/federation/mod.rs | 2 | ||||
| -rw-r--r-- | src/federation/properties.rs | 33 |
3 files changed, 261 insertions, 12 deletions
diff --git a/src/federation/corpus.rs b/src/federation/corpus.rs new file mode 100644 index 0000000..27c1ab7 --- /dev/null +++ b/src/federation/corpus.rs @@ -0,0 +1,238 @@ +//! What each revision of federation 1 takes, refuses and reads, as fixed bytes +//! (`docs/federation-tests.md`, The corpus): for each revision this continuum knows, a file +//! in `corpus/` of histories generated at that revision, each with what became of every +//! event and what the store reads after, written once when the revision is made +//! (`write_the_corpus`) and never edited after. Every later continuum judges them alike: a +//! change to judging that alters what an earlier revision's corpus says comes as a later +//! revision. + +use std::collections::BTreeMap; +use std::fmt::Write as _; +use std::path::PathBuf; + +use super::fold::Federation; +use super::properties::{self, Kind}; +use super::revision::Revision; +use super::store::Id; +use super::store::memory::{Refusal, Store}; +use crate::testrand::Rng; + +/// The seeds each kind of history is generated from. +const SEEDS: u64 = 4; + +/// The kinds of history generated: with an adversary or not, versions naming checkpoints +/// or not, and versions this continuum doesn't read or not. +fn kinds() -> Vec<Kind> { + let mut kinds = Vec::new(); + for adversary in [false, true] { + for checkpoints in [false, true] { + for unread in [false, true] { + kinds.push(Kind { + adversary, + checkpoints, + unread, + }); + } + } + } + kinds +} + +fn dir() -> PathBuf { + PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("src/federation/corpus") +} + +/// The file of `revision`'s corpus: by its number and the feature it adds, or `base`. +fn file(revision: Revision) -> PathBuf { + let name = match revision.features().last() { + None => "0-base".to_owned(), + Some(feature) => format!("{}-{}", revision.0, feature.name()), + }; + dir().join(format!("{name}.txt")) +} + +/// The first line of `revision`'s corpus, naming it by its ID, so that a renamed feature +/// fails as a changed judgment does. +fn header(revision: Revision) -> String { + format!( + "continuum federation 1, {revision}, ID {}: never edited once released", + revision.id() + ) +} + +/// What became of `id` in `store`, by kind: never a refusal's words, which may change. +fn became(store: &Store<Federation>, id: &Id) -> String { + if store.stopped().is_some_and(|(at, ..)| at == id) { + return "stopped at".to_owned(); + } + if store.held_back().iter().any(|(held, _)| held == id) { + return "held back".to_owned(); + } + if store.holds(id) { + return "taken".to_owned(); + } + if store.get(id).is_some() { + return "kept".to_owned(); + } + match store.refusal(id) { + Some(Refusal::None) => "refused: none".to_owned(), + Some(Refusal::Judged(_)) => "refused: judged".to_owned(), + Some(Refusal::BuiltOn(_)) => "refused: built on a refused one".to_owned(), + Some(Refusal::NotAbove) => "refused: not above the checkpoint".to_owned(), + Some(Refusal::Own) => "refused: its own".to_owned(), + Some(Refusal::Dropped) => "refused: dropped".to_owned(), + None if store.is_waiting(id) => "waiting".to_owned(), + None => "gone with a move".to_owned(), + } +} + +/// What `store` reads: its checkpoint, the current version, the values at places, the +/// members, and the event it stopped at; a line of JSON. +fn reads(store: &Store<Federation>) -> String { + let state = store.state(); + let values: BTreeMap<String, String> = state + .values() + .into_iter() + .map(|(path, value)| (path, String::from_utf8_lossy(&value.bytes()).into_owned())) + .collect(); + serde_json::json!({ + "checkpoint": Id::of(store.checkpoint()).to_string(), + "current": state.current().hash.to_string(), + "values": values, + "members": state.members(), + "stopped": store.stopped().map(|(id, ..)| id.to_string()), + }) + .to_string() +} + +/// A case: a root, and its events offered in the order written; what each became, and +/// what the store reads after, as the corpus spells them. +fn case(label: &str, root: &[u8], events: &[Vec<u8>]) -> String { + let mut store = Store::new(root.to_vec(), Vec::new()).expect("a root"); + for event in events { + store.offer(event.clone()); + } + let mut text = format!("case {label}\nroot {}\n", String::from_utf8_lossy(root)); + for event in events { + let _ = writeln!(text, "event {}", String::from_utf8_lossy(event)); + let _ = writeln!(text, "became {}", became(&store, &Id::of(event))); + } + let _ = writeln!(text, "reads {}", reads(&store)); + text +} + +/// `revision`'s corpus, generated: the histories of every kind and seed, the first +/// version following `revision`. +fn generated(revision: Revision) -> String { + let mut text = header(revision) + "\n"; + for kind in kinds() { + for seed in 0..SEEDS { + let mut rng = Rng::new(seed); + let history = properties::generate_at(&mut rng, kind, Some(revision)); + let label = format!("seed {seed}, {kind:?}"); + text += &case(&label, &history.root, &history.events); + } + } + text +} + +/// A corpus's cases, read: each its label, its root, and its events with what each +/// became, and what the store reads after. +struct Case { + label: String, + root: Vec<u8>, + events: Vec<(Vec<u8>, String)>, + reads: String, +} + +fn parse(text: &str) -> Result<(String, Vec<Case>), String> { + let mut lines = text.lines(); + let header = lines.next().ok_or("an empty corpus")?.to_owned(); + let mut cases: Vec<Case> = Vec::new(); + let mut event: Option<Vec<u8>> = None; + for line in lines { + let (word, rest) = line.split_once(' ').ok_or(format!("no line: {line:?}"))?; + let current = cases.last_mut(); + match (word, current) { + ("case", _) => cases.push(Case { + label: rest.to_owned(), + root: Vec::new(), + events: Vec::new(), + reads: String::new(), + }), + ("root", Some(case)) => case.root = rest.as_bytes().to_vec(), + ("event", Some(_)) => event = Some(rest.as_bytes().to_vec()), + ("became", Some(case)) => { + let bytes = event.take().ok_or("`became` without its event")?; + case.events.push((bytes, rest.to_owned())); + } + ("reads", Some(case)) => case.reads = rest.to_owned(), + _ => return Err(format!("no line of a corpus: {line:?}")), + } + } + Ok((header, cases)) +} + +/// Writes the corpus of every revision this continuum knows that has none: once, when a +/// revision is made, its file then committed and never edited. Run by hand: +/// `cargo test --features federation write_the_corpus -- --ignored`. +#[test] +#[ignore = "writes into the source tree: run by hand when a revision is made"] +fn write_the_corpus() { + std::fs::create_dir_all(dir()).expect("the corpus's directory"); + for revision in Revision::known() { + let path = file(revision); + if !path.exists() { + std::fs::write(&path, generated(revision)).expect("the corpus written"); + println!("wrote {}", path.display()); + } + } +} + +/// Every revision this continuum knows has its corpus, which it judges and reads as the +/// corpus says. +#[test] +fn every_revision_judges_as_its_corpus_says() { + for revision in Revision::known() { + let path = file(revision); + let text = std::fs::read_to_string(&path).unwrap_or_else(|_| { + panic!( + "no corpus of {revision} ({}): write it once, as the revision is made, with \ + `cargo test --features federation write_the_corpus -- --ignored`, and \ + commit it", + path.display() + ) + }); + let (named, cases) = parse(&text).unwrap_or_else(|why| panic!("{}: {why}", path.display())); + assert_eq!( + named, + header(revision), + "{}: another revision", + path.display() + ); + assert!(!cases.is_empty(), "{}: no case", path.display()); + for case in cases { + let events: Vec<Vec<u8>> = case.events.iter().map(|(bytes, _)| bytes.clone()).collect(); + let judged = self::case(&case.label, &case.root, &events); + let (_, again) = parse(&format!("{named}\n{judged}")).expect("as written"); + let again = &again[0]; + for ((bytes, was), (_, is)) in case.events.iter().zip(&again.events) { + assert_eq!( + was, + is, + "{}, {}: the event {} became otherwise", + path.display(), + case.label, + Id::of(bytes) + ); + } + assert_eq!( + case.reads, + again.reads, + "{}, {}: the store reads otherwise", + path.display(), + case.label + ); + } + } +} diff --git a/src/federation/mod.rs b/src/federation/mod.rs index 2edc7c4..9444712 100644 --- a/src/federation/mod.rs +++ b/src/federation/mod.rs @@ -11,6 +11,8 @@ pub(crate) mod agent; #[cfg(test)] mod attacks; pub(crate) mod client; +#[cfg(test)] +mod corpus; pub(crate) mod event; pub(crate) mod fold; pub(crate) mod fork; diff --git a/src/federation/properties.rs b/src/federation/properties.rs index 214bb27..b45b664 100644 --- a/src/federation/properties.rs +++ b/src/federation/properties.rs @@ -17,7 +17,7 @@ use super::harness::{self, Party, Spec}; use super::held::Holding; use super::jcs::Json; use super::model::{Model, Verdict}; -use super::revision::Feature; +use super::revision::{Feature, Revision}; use super::store::memory::{Offered, Refusal, Store}; use super::store::{Fold, Id}; use super::version::Version; @@ -30,9 +30,9 @@ const MOST: usize = 30; /// A root, and events in the order written. #[derive(Clone)] -struct History { - root: Vec<u8>, - events: Vec<Vec<u8>>, +pub(super) struct History { + pub(super) root: Vec<u8>, + pub(super) events: Vec<Vec<u8>>, } impl History { @@ -87,11 +87,11 @@ impl History { /// How a history is written: whether an adversary takes part, whether versions name /// checkpoints, and whether parties propose versions this continuum doesn't read, at /// which a store stops, which events then take in the order they come. -#[derive(Clone, Copy)] -struct Kind { - adversary: bool, - checkpoints: bool, - unread: bool, +#[derive(Clone, Copy, Debug)] +pub(super) struct Kind { + pub(super) adversary: bool, + pub(super) checkpoints: bool, + pub(super) unread: bool, } /// One of `ids`, of the latest five more often than not. @@ -104,6 +104,12 @@ fn pick(rng: &mut Rng, ids: &[Id]) -> Id { } fn generate(rng: &mut Rng, kind: Kind) -> History { + generate_at(rng, kind, None) +} + +/// A history of `kind`, its first version following `revision`, or, where none is given, +/// the base revision or one with merge events alike. +pub(super) fn generate_at(rng: &mut Rng, kind: Kind, revision: Option<Revision>) -> History { let count = rng.between(3, 5); let parties: Vec<Party> = (0..count) .map(|i| Party::new(&format!("p{i}"), i as u8 + 1)) @@ -112,9 +118,12 @@ fn generate(rng: &mut Rng, kind: Kind) -> History { let refs: Vec<&Party> = parties.iter().collect(); let mut first = Spec::first(&refs, &[("names/{party}", harness::str("{party}"))]); // Half the federations begin at a revision with merge events, which nodes then sign. - if rng.chance(0.5) { - first.revision = Feature::MergeEvents.revision(); - } + let merging = rng.chance(0.5); + first.revision = revision.unwrap_or(if merging { + Feature::MergeEvents.revision() + } else { + Revision::default() + }); let root = first.root(); let root_id = Id::of(&root); let mut world: Store<Federation> = Store::new(root.clone(), Vec::new()).expect("a root"); |
