#![cfg(test)]
use std::error;
use std::sync::{Arc, Barrier};
use std::thread;
use super::item::{Item, ModelVisibility, System, User};
use super::store::{
Error, Snapshot, Store, Version, hold_write_lock, install_commit_overlap, poison,
};
use crate::redact_tests::{SECRET, assert_redacted, assert_states};
use crate::value::content::Part;
fn system(text: &str) -> Item {
Item::System(System::new(
"test".into(),
text.into(),
ModelVisibility::Visible,
))
}
fn user(text: &str) -> Item {
Item::User(User::new(
vec![Part::text(text.into())],
ModelVisibility::Visible,
))
}
fn texts(items: &[Item]) -> Vec<&str> {
items
.iter()
.map(|item| match item {
Item::System(item) => item.text(),
Item::User(item) => item.parts()[0].fields().text(),
Item::Assistant(_) | Item::ToolResult(_) => panic!("unexpected test item"),
})
.collect()
}
#[test]
fn version_is_ordered_stable_and_never_implicitly_numeric() {
assert_eq!(Version::ZERO.as_u64(), 0);
assert_eq!(Version::MAX.as_u64(), u64::MAX);
assert!(Version::from_u64(8) > Version::from_u64(7));
assert_eq!(Version::from_u64(42).to_string(), "42");
}
#[test]
fn error_values_are_typed_descriptive_and_source_free() {
let conflict = Error::VersionConflict {
expected: Version::from_u64(2),
actual: Version::from_u64(3),
};
assert_eq!(
conflict.to_string(),
"transcript version conflict: expected 2, actual 3"
);
let overflow = Error::VersionOverflow {
current: Version::MAX,
delta: 1,
};
assert_eq!(
overflow.to_string(),
"transcript version overflow: current 18446744073709551615, increment 1"
);
assert_eq!(
Error::Poisoned.to_string(),
"transcript store lock poisoned"
);
assert!(error::Error::source(&conflict).is_none());
}
#[test]
fn fresh_from_items_and_default_have_explicit_epoch_policy() {
let defaulted = Store::default();
assert_eq!(
defaulted.snapshot_reader().version().unwrap(),
Version::ZERO
);
assert!(defaulted.reader().items().unwrap().is_empty());
let source = vec![system("seed")];
let retained = source.clone();
let store = Store::from_items(source);
let snapshot = store.snapshot_reader().snapshot().unwrap();
assert_eq!(snapshot.version(), Version::ZERO);
assert_eq!(texts(snapshot.items()), ["seed"]);
assert_eq!(texts(&retained), ["seed"]);
}
#[test]
fn reader_and_snapshot_extraction_return_owned_vectors() {
let store = Store::from_items(vec![user("owned"), system("tail")]);
let reader = store.reader();
let snapshots = store.snapshot_reader();
let mut read = reader.items().unwrap();
read[0] = system("mutated read");
assert_eq!(texts(&reader.items().unwrap()), ["owned", "tail"]);
let first = snapshots.snapshot().unwrap();
let first_version = first.version();
let (_, mut first_items) = first.into_parts();
first_items[1] = system("mutated snapshot");
let second = snapshots.snapshot().unwrap();
assert_eq!(texts(second.items()), ["owned", "tail"]);
assert_eq!(first_version, second.version());
let cloned_reader = reader.clone();
let cloned_snapshots = snapshots.clone();
assert_eq!(texts(&cloned_reader.items().unwrap()), ["owned", "tail"]);
assert_eq!(cloned_snapshots.version().unwrap(), second.version());
}
#[test]
fn unchanged_snapshots_share_one_immutable_backing() {
let store = Store::from_items(vec![system("seed")]);
let snapshots = store.snapshot_reader();
let first = snapshots.snapshot().unwrap();
let second = snapshots.snapshot().unwrap();
assert!(first.shares_items_with(&second));
assert_eq!(texts(first.items()), ["seed"]);
}
#[test]
fn staged_appends_materialize_once_and_keep_older_snapshots_stable() {
let source = Store::from_items(vec![system("seed")]);
let staged = source.fork().unwrap();
let before = staged.snapshot_reader().snapshot().unwrap();
staged
.appender()
.append_batch(vec![system("one"), system("two")])
.unwrap();
let first_after = staged.snapshot_reader().snapshot().unwrap();
let second_after = staged.snapshot_reader().snapshot().unwrap();
assert_eq!(texts(before.items()), ["seed"]);
assert_eq!(texts(first_after.items()), ["seed", "one", "two"]);
assert!(!before.shares_items_with(&first_after));
assert!(first_after.shares_items_with(&second_after));
}
#[test]
fn concurrent_first_staged_readers_share_the_single_materialization() {
const READERS: usize = 8;
let source = Store::from_items(vec![system("seed")]);
let staged = source.fork().unwrap();
staged.appender().append(system("tail")).unwrap();
let barrier = Arc::new(Barrier::new(READERS));
let mut readers = Vec::new();
for _ in 0..READERS {
let snapshots = staged.snapshot_reader();
let barrier = Arc::clone(&barrier);
readers.push(thread::spawn(move || {
barrier.wait();
snapshots.snapshot().unwrap()
}));
}
let snapshots: Vec<_> = readers
.into_iter()
.map(|reader| reader.join().unwrap())
.collect();
assert!(
snapshots[1..]
.iter()
.all(|snapshot| snapshots[0].shares_items_with(snapshot))
);
assert_eq!(texts(snapshots[0].items()), ["seed", "tail"]);
}
#[test]
fn shared_snapshot_install_preserves_the_candidate_backing() {
let store = Store::from_items(vec![system("old")]);
let candidate = Snapshot::new(Version::from_u64(1), vec![system("new")]);
let retained = candidate.clone();
assert_eq!(
store
.replacer()
.install_snapshot_if_version(candidate, Version::ZERO)
.unwrap(),
Version::from_u64(1)
);
let installed = store.snapshot_reader().snapshot().unwrap();
assert!(retained.shares_items_with(&installed));
assert_eq!(texts(installed.items()), ["new"]);
}
#[test]
fn shared_snapshot_install_panics_on_a_mismatched_candidate_version_without_mutation() {
let store = Store::from_items(vec![system("live")]);
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
let _ = store.replacer().install_snapshot_if_version(
Snapshot::new(Version::from_u64(7), vec![system("candidate")]),
Version::ZERO,
);
}));
assert!(
result.is_err(),
"the internal version invariant must fail in release too"
);
let unchanged = store.snapshot_reader().snapshot().unwrap();
assert_eq!(unchanged.version(), Version::ZERO);
assert_eq!(texts(unchanged.items()), ["live"]);
}
#[test]
fn shared_snapshot_install_rejects_conflict_and_overflow_without_mutation() {
let store = Store::from_items(vec![system("live")]);
let candidate = Snapshot::new(Version::from_u64(2), vec![system("candidate")]);
assert_eq!(
store
.replacer()
.install_snapshot_if_version(candidate, Version::from_u64(1)),
Err(Error::VersionConflict {
expected: Version::from_u64(1),
actual: Version::ZERO,
})
);
assert_eq!(
texts(store.snapshot_reader().snapshot().unwrap().items()),
["live"]
);
let full = Store::restore(Snapshot::new(Version::MAX, vec![system("full")]));
assert_eq!(
full.replacer().install_snapshot_if_version(
Snapshot::new(Version::MAX, vec![system("candidate")]),
Version::MAX,
),
Err(Error::VersionOverflow {
current: Version::MAX,
delta: 1,
})
);
assert_eq!(
texts(full.snapshot_reader().snapshot().unwrap().items()),
["full"]
);
}
#[test]
fn shared_snapshot_install_clears_a_staged_tail() {
let source = Store::from_items(vec![system("seed")]);
let staged = source.fork().unwrap();
staged.appender().append(system("discarded")).unwrap();
let candidate = Snapshot::new(Version::from_u64(2), vec![system("replacement")]);
staged
.replacer()
.install_snapshot_if_version(candidate, Version::from_u64(1))
.unwrap();
assert_eq!(
texts(staged.snapshot_reader().snapshot().unwrap().items()),
["replacement"]
);
}
#[test]
fn snapshot_extraction_covers_clean_and_aliased_suffix_paths() {
let clean = Store::from_items(vec![system("seed")]).fork().unwrap();
assert_eq!(texts(clean.into_snapshot().unwrap().items()), ["seed"]);
let live = Store::from_items(vec![system("seed")]);
assert_eq!(
texts(
live.into_snapshot_with_suffix(vec![system("suffix")])
.unwrap()
.items()
),
["seed", "suffix"]
);
let aliased = Store::from_items(vec![system("seed")]).fork().unwrap();
let reader = aliased.snapshot_reader();
let snapshot = aliased
.into_snapshot_with_suffix(vec![system("suffix")])
.unwrap();
assert_eq!(texts(snapshot.items()), ["seed", "suffix"]);
assert_eq!(texts(reader.snapshot().unwrap().items()), ["seed"]);
}
#[test]
fn staged_suffix_joins_the_pending_tail_in_one_snapshot() {
let source = Store::from_items(vec![system("seed")]);
let staged = source.fork().unwrap();
let retained_base = staged.snapshot_reader().snapshot().unwrap();
staged.appender().append(system("rewrite")).unwrap();
let combined = staged
.into_snapshot_with_suffix(vec![system("input")])
.unwrap();
assert_eq!(texts(retained_base.items()), ["seed"]);
assert_eq!(texts(combined.items()), ["seed", "rewrite", "input"]);
assert!(!retained_base.shares_items_with(&combined));
}
#[test]
fn append_and_batch_preserve_source_order_and_empty_is_noop() {
let store = Store::new();
let append = store.appender();
let snapshots = store.snapshot_reader();
assert_eq!(append.append(system("one")).unwrap().as_u64(), 1);
assert_eq!(
append
.append_batch(vec![system("two"), system("three")])
.unwrap()
.as_u64(),
3
);
let before = snapshots.snapshot().unwrap();
assert_eq!(append.append_batch(Vec::new()).unwrap(), before.version());
let after = snapshots.snapshot().unwrap();
assert_eq!(after.version(), before.version());
assert_eq!(texts(after.items()), ["one", "two", "three"]);
let cloned = append.clone();
assert_eq!(cloned.append(system("four")).unwrap().as_u64(), 4);
}
#[test]
fn conditional_append_checks_even_empty_batches_and_never_overwrites() {
let store = Store::from_items(vec![system("seed")]);
let append = store.appender();
let snapshots = store.snapshot_reader();
let expected = snapshots.version().unwrap();
assert_eq!(
append
.append_batch_if_version(Vec::new(), expected)
.unwrap(),
expected
);
append.append(system("winner")).unwrap();
let actual = snapshots.version().unwrap();
assert_eq!(
append.append_batch_if_version(vec![system("stale")], expected),
Err(Error::VersionConflict { expected, actual })
);
assert_eq!(
append.append_batch_if_version(Vec::new(), expected),
Err(Error::VersionConflict { expected, actual })
);
assert_eq!(texts(&store.reader().items().unwrap()), ["seed", "winner"]);
}
#[test]
fn replace_and_cas_advance_once_and_conflicts_preserve_winner() {
let store = Store::from_items(vec![system("seed"), system("old")]);
let replace = store.replacer();
let snapshots = store.snapshot_reader();
let first = replace.replace(vec![system("replacement")]).unwrap();
assert_eq!(first.as_u64(), 1);
let winner = replace
.replace_if_version(vec![system("winner")], first)
.unwrap();
assert_eq!(winner.as_u64(), 2);
assert_eq!(
replace.replace_if_version(vec![system("stale")], first),
Err(Error::VersionConflict {
expected: first,
actual: winner,
})
);
assert_eq!(texts(snapshots.snapshot().unwrap().items()), ["winner"]);
let cloned = replace.clone();
assert_eq!(cloned.replace(Vec::new()).unwrap().as_u64(), 3);
assert!(store.reader().items().unwrap().is_empty());
}
#[test]
fn restore_continues_saved_version_while_from_items_starts_fresh() {
let saved = Snapshot::new(Version::from_u64(23), vec![system("saved")]);
let clone = saved.clone();
let (version, items) = clone.into_parts();
assert_eq!(version.as_u64(), 23);
assert_eq!(texts(&items), ["saved"]);
let restored = Store::restore(saved);
assert_eq!(restored.snapshot_reader().version().unwrap().as_u64(), 23);
assert_eq!(
restored.appender().append(system("next")).unwrap().as_u64(),
24
);
assert_eq!(
restored
.replacer()
.replace(vec![system("last")])
.unwrap()
.as_u64(),
25
);
let fresh = Store::from_items(restored.reader().items().unwrap());
assert_eq!(fresh.snapshot_reader().version().unwrap(), Version::ZERO);
}
#[test]
fn forked_and_live_histories_diverge_after_copy_on_write() {
let source = Store::from_items(vec![system("seed")]);
let forked = source.fork().unwrap();
let frozen = source.snapshot_reader().snapshot().unwrap();
source.appender().append(system("source")).unwrap();
forked.appender().append(system("forked")).unwrap();
assert_eq!(texts(frozen.items()), ["seed"]);
let source_snapshot = source.snapshot_reader().snapshot().unwrap();
let forked_snapshot = forked.snapshot_reader().snapshot().unwrap();
assert_eq!(source_snapshot.version(), forked_snapshot.version());
assert!(!source_snapshot.shares_items_with(&forked_snapshot));
assert_eq!(texts(source_snapshot.items()), ["seed", "source"]);
assert_eq!(texts(forked_snapshot.items()), ["seed", "forked"]);
assert_eq!(texts(&frozen.into_parts().1), ["seed"]);
}
#[test]
fn staged_tail_reads_replaces_and_owned_extraction_preserve_order() {
let source = Store::from_items(vec![system("seed")]);
let staged = source.fork().unwrap();
staged
.appender()
.append_batch(vec![system("one"), system("two")])
.unwrap();
let nested = staged.fork().unwrap();
nested.appender().append(system("nested")).unwrap();
assert_eq!(
texts(&nested.reader().items().unwrap()),
["seed", "one", "two", "nested"]
);
assert_eq!(
texts(&staged.snapshot_reader().snapshot().unwrap().into_parts().1),
["seed", "one", "two"]
);
staged
.replacer()
.replace(vec![system("replacement")])
.unwrap();
staged.appender().append(system("tail")).unwrap();
assert_eq!(
texts(&staged.into_items().unwrap()),
["replacement", "tail"]
);
assert_eq!(texts(&source.reader().items().unwrap()), ["seed"]);
}
#[test]
fn owned_extraction_falls_back_when_a_capability_is_still_alive() {
assert_eq!(
texts(
&Store::from_items(vec![system("owned")])
.into_items()
.unwrap()
),
["owned"]
);
let store = Store::from_items(vec![system("seed")]);
let reader = store.reader();
assert_eq!(texts(&store.into_items().unwrap()), ["seed"]);
assert_eq!(texts(&reader.items().unwrap()), ["seed"]);
}
#[test]
fn overflow_is_typed_and_every_operation_is_all_or_nothing() {
let near = Store::restore(Snapshot::new(
Version::from_u64(u64::MAX - 2),
vec![system("existing")],
));
assert_eq!(
near.appender()
.append_batch(vec![system("one"), system("two")])
.unwrap(),
Version::MAX
);
let before = near.snapshot_reader().snapshot().unwrap();
let expected_append_error = Error::VersionOverflow {
current: Version::MAX,
delta: 1,
};
assert_eq!(
near.appender().append(system("overflow")),
Err(expected_append_error)
);
assert_eq!(
near.appender()
.append_batch_if_version(vec![system("overflow")], Version::MAX),
Err(expected_append_error)
);
assert_eq!(
near.replacer().replace(vec![system("overflow")]),
Err(expected_append_error)
);
assert_eq!(
near.replacer()
.replace_if_version(vec![system("overflow")], Version::MAX),
Err(expected_append_error)
);
let after = near.snapshot_reader().snapshot().unwrap();
assert_eq!(after.version(), before.version());
assert_eq!(texts(after.items()), texts(before.items()));
assert_eq!(
near.replacer()
.replace_if_version(Vec::new(), Version::from_u64(u64::MAX - 1)),
Err(Error::VersionConflict {
expected: Version::from_u64(u64::MAX - 1),
actual: Version::MAX,
})
);
assert_eq!(
near.appender().append_batch(Vec::new()).unwrap(),
Version::MAX
);
}
#[test]
fn append_batch_overflow_by_two_from_max_minus_one_is_atomic() {
let current = Version::from_u64(u64::MAX - 1);
let store = Store::restore(Snapshot::new(current, vec![system("unchanged")]));
let before = store.snapshot_reader().snapshot().unwrap();
assert_eq!(
store
.appender()
.append_batch(vec![system("first"), system("second")]),
Err(Error::VersionOverflow { current, delta: 2 })
);
let after = store.snapshot_reader().snapshot().unwrap();
assert_eq!(after.version(), before.version());
assert_eq!(texts(after.items()), texts(before.items()));
}
#[test]
fn conditional_append_batch_overflow_by_two_from_max_minus_one_is_atomic() {
let current = Version::from_u64(u64::MAX - 1);
let store = Store::restore(Snapshot::new(current, vec![system("unchanged")]));
let before = store.snapshot_reader().snapshot().unwrap();
assert_eq!(
store
.appender()
.append_batch_if_version(vec![system("first"), system("second")], current,),
Err(Error::VersionOverflow { current, delta: 2 })
);
let after = store.snapshot_reader().snapshot().unwrap();
assert_eq!(after.version(), before.version());
assert_eq!(texts(after.items()), texts(before.items()));
}
#[test]
fn concurrent_cas_has_exactly_one_winner_and_never_loses_it() {
const CONTENDERS: usize = 24;
let store = Store::new();
let replace = store.replacer();
let start = Arc::new(Barrier::new(CONTENDERS + 1));
let mut workers = Vec::new();
for index in 0..CONTENDERS {
let replace = replace.clone();
let start = Arc::clone(&start);
workers.push(thread::spawn(move || {
start.wait();
replace.replace_if_version(vec![system(&index.to_string())], Version::ZERO)
}));
}
start.wait();
let mut successes = 0;
let mut conflicts = 0;
for worker in workers {
match worker.join().expect("CAS worker must not panic") {
Ok(version) => {
successes += 1;
assert_eq!(version.as_u64(), 1);
}
Err(Error::VersionConflict { expected, actual }) => {
conflicts += 1;
assert_eq!(expected, Version::ZERO);
assert_eq!(actual.as_u64(), 1);
}
Err(error) => panic!("unexpected CAS error: {error}"),
}
}
assert_eq!(successes, 1);
assert_eq!(conflicts, CONTENDERS - 1);
let final_state = store.snapshot_reader().snapshot().unwrap();
assert_eq!(final_state.version().as_u64(), 1);
assert_eq!(final_state.items().len(), 1);
}
#[test]
fn concurrent_batches_commit_whole_and_preserve_each_source_order() {
let store = Store::new();
let start = Arc::new(Barrier::new(3));
let left = {
let append = store.appender();
let start = Arc::clone(&start);
thread::spawn(move || {
start.wait();
append.append_batch(vec![system("a1"), system("a2")])
})
};
let right = {
let append = store.appender();
let start = Arc::clone(&start);
thread::spawn(move || {
start.wait();
append.append_batch(vec![system("b1"), system("b2")])
})
};
start.wait();
left.join().expect("left worker must not panic").unwrap();
right.join().expect("right worker must not panic").unwrap();
let snapshot = store.snapshot_reader().snapshot().unwrap();
assert_eq!(snapshot.version().as_u64(), 4);
let committed = texts(snapshot.items());
assert!(committed == ["a1", "a2", "b1", "b2"] || committed == ["b1", "b2", "a1", "a2"]);
}
#[test]
fn overlapping_snapshots_keep_alternating_append_replace_pairs_consistent() {
let store = Store::from_items(vec![system("seed")]);
let mut expected_items = vec![system("seed")];
let mut expected_version = 0_u64;
for round in 0..8 {
let before = store.snapshot_reader().snapshot().unwrap();
assert_eq!(before.version(), Version::from_u64(expected_version));
assert_eq!(texts(before.items()), texts(&expected_items));
let replacing = round % 2 == 1;
let candidate = vec![
system(&format!("round-{round}-first")),
system(&format!("round-{round}-second")),
];
let writer_candidate = candidate.clone();
let overlap = install_commit_overlap(&store);
let writer = if replacing {
let replace = store.replacer();
thread::spawn(move || replace.replace(writer_candidate))
} else {
let append = store.appender();
thread::spawn(move || append.append_batch(writer_candidate))
};
overlap.wait_for_writer();
let snapshots = store.snapshot_reader();
let reader = thread::spawn(move || snapshots.snapshot());
overlap.wait_for_reader();
overlap.release_writer();
if replacing {
expected_items = candidate;
expected_version += 1;
} else {
expected_version += candidate.len() as u64;
expected_items.extend(candidate);
}
assert_eq!(
writer.join().expect("writer must not panic").unwrap(),
Version::from_u64(expected_version)
);
let observed = reader.join().expect("reader must not panic").unwrap();
assert_eq!(observed.version(), Version::from_u64(expected_version));
assert_eq!(texts(observed.items()), texts(&expected_items));
}
}
#[test]
fn overlapping_batch_reader_sees_complete_before_and_after_without_prefixes() {
let store = Store::from_items(vec![system("before")]);
let reader = store.reader();
let before = reader.items().unwrap();
assert_eq!(texts(&before), ["before"]);
let overlap = install_commit_overlap(&store);
let writer = {
let append = store.appender();
thread::spawn(move || {
append.append_batch(vec![system("one"), system("two"), system("three")])
})
};
overlap.wait_for_writer();
let competing_reader = thread::spawn(move || reader.items());
overlap.wait_for_reader();
overlap.release_writer();
assert_eq!(
writer.join().expect("batch writer must not panic").unwrap(),
Version::from_u64(3)
);
let after = competing_reader
.join()
.expect("batch reader must not panic")
.unwrap();
assert_eq!(texts(&after), ["before", "one", "two", "three"]);
}
#[test]
fn concurrent_snapshots_are_version_item_count_consistent() {
const WRITES: usize = 200;
const READERS: usize = 4;
let store = Store::new();
let start = Arc::new(Barrier::new(READERS + 2));
let writer = {
let append = store.appender();
let start = Arc::clone(&start);
thread::spawn(move || {
start.wait();
for index in 0..WRITES {
append.append(system(&index.to_string())).unwrap();
}
})
};
let mut readers = Vec::new();
for _ in 0..READERS {
let snapshots = store.snapshot_reader();
let start = Arc::clone(&start);
readers.push(thread::spawn(move || {
start.wait();
for _ in 0..WRITES {
let snapshot = snapshots.snapshot().unwrap();
assert_eq!(snapshot.version().as_u64() as usize, snapshot.items().len());
}
}));
}
start.wait();
writer.join().expect("writer must not panic");
for reader in readers {
reader.join().expect("snapshot reader must not panic");
}
let final_state = store.snapshot_reader().snapshot().unwrap();
assert_eq!(final_state.version().as_u64() as usize, WRITES);
assert_eq!(final_state.items().len(), WRITES);
}
#[test]
fn poisoned_lock_fails_closed_on_every_facet() {
let store = Store::from_items(vec![system("before")]);
let poisoner = store.clone();
assert!(thread::spawn(move || poison(&poisoner)).join().is_err());
assert!(matches!(store.reader().items(), Err(Error::Poisoned)));
assert!(matches!(
store.snapshot_reader().snapshot(),
Err(Error::Poisoned)
));
assert_eq!(store.snapshot_reader().version(), Err(Error::Poisoned));
assert!(matches!(store.fork(), Err(Error::Poisoned)));
assert_eq!(
store.appender().append(system("late")),
Err(Error::Poisoned)
);
assert_eq!(
store
.appender()
.append_batch_if_version(Vec::new(), Version::ZERO),
Err(Error::Poisoned)
);
assert_eq!(store.replacer().replace(Vec::new()), Err(Error::Poisoned));
assert_eq!(
store
.replacer()
.replace_if_version(Vec::new(), Version::ZERO),
Err(Error::Poisoned)
);
assert!(matches!(store.into_items(), Err(Error::Poisoned)));
}
#[test]
fn every_handle_debug_reports_the_version_behind_it() {
let store = Store::from_items(vec![system("one"), system("two")]);
assert_eq!(format!("{store:?}"), "Store { version: Version(0) }");
assert_eq!(
format!("{:?}", store.reader()),
"Reader { version: Version(0) }"
);
assert_eq!(
format!("{:?}", store.snapshot_reader()),
"SnapshotReader { version: Version(0) }"
);
assert_eq!(
format!("{:?}", store.appender()),
"Appender { version: Version(0) }"
);
assert_eq!(
format!("{:?}", store.replacer()),
"Replacer { version: Version(0) }"
);
store
.appender()
.append(system("three"))
.expect("append succeeds");
assert_eq!(format!("{store:?}"), "Store { version: Version(1) }");
}
#[test]
fn snapshot_debug_keeps_the_version_and_redacts_the_items() {
let snapshot = Snapshot::new(Version::from_u64(4), vec![system(SECRET)]);
assert_redacted(&snapshot);
assert_states(
&snapshot,
&[
"version: Version(4)",
"text: <21 bytes>",
r#"subtype: "test""#,
],
);
}
#[test]
fn a_handle_debug_never_waits_for_a_live_writer() {
let store = Store::new();
let held = Barrier::new(2);
let release = Barrier::new(2);
thread::scope(|scope| {
scope.spawn(|| hold_write_lock(&store, &held, &release));
held.wait();
assert_eq!(format!("{store:?}"), "Store { version: <locked> }");
assert_eq!(
format!("{:?}", store.reader()),
"Reader { version: <locked> }"
);
release.wait();
});
assert_eq!(format!("{store:?}"), "Store { version: Version(0) }");
}
#[cfg(feature = "serde")]
mod serde_format {
use super::super::item::{Item, ModelVisibility, System};
use super::super::store::{Snapshot, Version};
use crate::wire::wire_tests::{assert_expecting, assert_refusal, encode, round_trip};
fn snapshot() -> Snapshot {
Snapshot::new(
Version::from_u64(4),
vec![Item::System(System::new(
"instruction".into(),
"Be brief.".into(),
ModelVisibility::Visible,
))],
)
}
#[test]
fn a_version_travels_as_the_persisted_integer_it_documents() {
for version in [Version::ZERO, Version::from_u64(7), Version::MAX] {
assert_eq!(round_trip(&version), version);
}
assert_eq!(encode(&Version::MAX), "18446744073709551615");
}
#[test]
fn a_snapshot_reads_from_both_forms_and_keeps_its_version_epoch() {
let restored = round_trip(&snapshot());
assert_eq!(restored.version(), Version::from_u64(4));
assert_eq!(encode(&restored), encode(&snapshot()));
let from_sequence: Snapshot =
serde_json::from_str(r#"[9,[]]"#).expect("the sequence form reads");
assert_eq!(from_sequence.version(), Version::from_u64(9));
assert!(from_sequence.items().is_empty());
}
#[test]
fn a_snapshot_refuses_an_unknown_repeated_missing_or_mistyped_document() {
assert_refusal(
serde_json::from_str::<Snapshot>(r#"{"version":0,"epoch":0}"#),
"unknown field `epoch`",
);
assert_refusal(
serde_json::from_str::<Snapshot>(r#"{"version":0,"version":0}"#),
"duplicate field `version`",
);
assert_refusal(
serde_json::from_str::<Snapshot>(r#"{"version":0}"#),
"missing field `items`",
);
assert_refusal(
serde_json::from_str::<Snapshot>("[0]"),
"every struct field",
);
assert_expecting::<Snapshot>("a transcript snapshot");
}
}