use happenstance_core::{
AppendCondition, AppendError, Event, EventStore, Query, ReadOptions, SequencePosition,
SequencedEvent, collect,
};
use proptest::prelude::{Just, Strategy, prop, prop_oneof};
use crate::Fixture;
use crate::fixtures::strategies::{any_event, any_query};
mod trailing;
use trailing::TrailingModel;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Anchor {
Unset,
First,
Middle,
Head,
BeyondHead,
}
#[derive(Debug, Clone)]
pub enum Op {
Append {
events: Vec<Event>,
},
AppendConditional {
events: Vec<Event>,
query: Query,
anchor: Anchor,
},
#[non_exhaustive]
Read {
query: Query,
from: Anchor,
to: Anchor,
backwards: bool,
limit: Option<usize>,
},
}
fn any_anchor() -> impl Strategy<Value = Anchor> {
prop::sample::select(vec![
Anchor::Unset,
Anchor::First,
Anchor::Middle,
Anchor::Head,
Anchor::BeyondHead,
])
}
fn any_to_anchor() -> impl Strategy<Value = Anchor> {
prop_oneof![
4 => Just(Anchor::Unset),
1 => prop::sample::select(vec![
Anchor::First,
Anchor::Middle,
Anchor::Head,
Anchor::BeyondHead,
]),
]
}
fn any_batch() -> impl Strategy<Value = Vec<Event>> {
prop::collection::vec(any_event(), 1..4)
}
fn any_op() -> impl Strategy<Value = Op> {
prop_oneof![
3 => any_batch().prop_map(|events| Op::Append { events }),
3 => (any_batch(), any_query(), any_anchor()).prop_map(|(events, query, anchor)| {
Op::AppendConditional { events, query, anchor }
}),
4 => (any_query(), any_anchor(), any_to_anchor(), prop::bool::ANY, prop::option::of(1usize..4))
.prop_map(|(query, from, to, backwards, limit)| {
Op::Read { query, from, to, backwards, limit }
}),
]
}
#[derive(Debug, Default)]
struct Model {
expected: Vec<Event>,
known: Vec<SequencedEvent>,
}
fn resolve(known: &[SequencedEvent], anchor: Anchor) -> Option<SequencePosition> {
match anchor {
Anchor::Unset => None,
Anchor::First => known.first().map(|event| event.position),
Anchor::Middle => known.get(known.len() / 2).map(|event| event.position),
Anchor::Head => known.last().map(|event| event.position),
Anchor::BeyondHead => Some(
known
.last()
.and_then(|head| head.position.next())
.unwrap_or(SequencePosition::FIRST),
),
}
}
fn read_options(
known: &[SequencedEvent],
from: Anchor,
to: Anchor,
backwards: bool,
limit: Option<usize>,
) -> ReadOptions {
let mut options = ReadOptions::new();
if let Some(from) = resolve(known, from) {
options = options.from(from);
}
if let Some(to) = resolve(known, to) {
options = options.to(to);
}
if backwards {
options = options.backwards();
}
if let Some(limit) = limit {
options = options.limit(limit);
}
options
}
fn select(known: &[SequencedEvent], query: &Query, options: ReadOptions) -> Vec<SequencedEvent> {
let matched = known
.iter()
.filter(|event| query.matches(event.event_type(), event.tags()));
let mut selected: Vec<SequencedEvent> = if options.backwards {
matched
.rev()
.filter(|event| options.from.is_none_or(|from| event.position <= from))
.filter(|event| options.to.is_none_or(|to| event.position >= to))
.cloned()
.collect()
} else {
matched
.filter(|event| options.from.is_none_or(|from| event.position >= from))
.filter(|event| options.to.is_none_or(|to| event.position <= to))
.cloned()
.collect()
};
if let Some(limit) = options.limit {
selected.truncate(limit);
}
selected
}
impl Model {
fn violation(&self, condition: &AppendCondition) -> Option<SequencePosition> {
self.known
.iter()
.find(|event| {
condition.is_violated_by(event.position, event.event_type(), event.tags())
})
.map(|event| event.position)
}
async fn reconcile<S: EventStore>(
&mut self,
store: &S,
appended: Option<SequencePosition>,
) -> Result<(), String> {
let observed = match collect(store.read(&Query::all(), ReadOptions::new())).await {
Ok(events) => events,
Err(err) => return Err(format!("reading the whole log failed: {err:?}")),
};
if observed.len() != self.expected.len() {
return Err(format!(
"the log holds {} event(s); {} were accepted",
observed.len(),
self.expected.len()
));
}
for (index, (seen, wanted)) in observed.iter().zip(&self.expected).enumerate() {
if &seen.event != wanted {
return Err(format!(
"the event at index {index} is not the one accepted there: \
read back {:?}, appended {wanted:?}",
seen.event
));
}
}
for pair in observed.windows(2) {
if pair[1].position <= pair[0].position {
return Err(format!(
"positions must be unique and strictly increasing in \
assignment order, but {} follows {}",
pair[1].position, pair[0].position
));
}
}
if let Some(appended) = appended {
let last = observed.last().map(|event| event.position);
if last != Some(appended) {
return Err(format!(
"`append` returned {appended}, but the last event in the log \
is at {last:?}"
));
}
}
self.known = observed;
Ok(())
}
async fn apply<S: EventStore>(&mut self, store: &S, op: &Op) -> Result<(), String> {
match op {
Op::Append { events } => {
let written = match store.append(events, None).await {
Ok(position) => position,
Err(err) => {
return Err(format!("an unconditional append was refused: {err:?}"));
}
};
self.expected.extend(events.iter().cloned());
self.reconcile(store, Some(written)).await
}
Op::AppendConditional {
events,
query,
anchor,
} => {
let condition = AppendCondition::new(query.clone())
.after_every_guard_opt(resolve(&self.known, *anchor));
let predicted = self.violation(&condition);
let result = store.append(events, Some(&condition)).await;
match (predicted, result) {
(Some(_), Err(AppendError::ConditionViolated(_))) => {
self.reconcile(store, None).await
}
(None, Ok(written)) => {
self.expected.extend(events.iter().cloned());
self.reconcile(store, Some(written)).await
}
(Some(conflict), Ok(written)) => Err(format!(
"the append was accepted at {written}, but the event at \
{conflict} matches {condition:?}"
)),
(None, Err(AppendError::ConditionViolated(violated))) => Err(format!(
"the append was rejected as {violated:?}, but no stored \
event matches {condition:?}"
)),
(_, Err(other)) => {
Err(format!("a conditional append failed outright: {other:?}"))
}
}
}
Op::Read {
query,
from,
to,
backwards,
limit,
} => {
let options = read_options(&self.known, *from, *to, *backwards, *limit);
let observed = match collect(store.read(query, options)).await {
Ok(events) => events,
Err(err) => return Err(format!("the read failed: {err:?}")),
};
let wanted = select(&self.known, query, options);
if observed == wanted {
Ok(())
} else {
Err(format!(
"read({query:?}, {options:?}) returned {}, and the model \
expected {}",
render(&observed),
render(&wanted)
))
}
}
}
}
}
fn render(events: &[SequencedEvent]) -> String {
let rendered: Vec<String> = events
.iter()
.map(|event| format!("{}:{}", event.position, event.event_type().as_str()))
.collect();
format!("[{}]", rendered.join(", "))
}
const MAX_OPS: usize = 8;
const MAX_SHRINK_MOVES: usize = 1024;
const MAX_GENERATION_RETRIES: usize = 8;
#[derive(Debug)]
enum Checker {
Strict(Model),
Trailing(TrailingModel),
}
impl Checker {
fn for_fixture<F: Fixture>() -> Self {
if F::READ_YOUR_OWN_WRITES.is_supported() {
Self::Strict(Model::default())
} else {
Self::Trailing(TrailingModel::default())
}
}
async fn apply<S: EventStore>(
&mut self,
store: &S,
index: usize,
op: &Op,
) -> Result<(), String> {
match self {
Self::Strict(model) => model.apply(store, op).await,
Self::Trailing(model) => model.apply(store, index, op).await,
}
}
}
async fn replay<F, O>(open: &O, ops: &[Op]) -> Option<String>
where
F: Fixture,
O: AsyncFn() -> F,
{
let fixture = open().await;
let store = fixture.connect().await;
let mut checker = Checker::for_fixture::<F>();
for (index, op) in ops.iter().enumerate() {
if let Err(failure) = checker.apply(&store, index, op).await {
return Some(format!("at op {index}, {op:?}: {failure}"));
}
}
None
}
pub mod rules {
#![allow(clippy::missing_panics_doc)]
use proptest::prelude::Strategy;
use proptest::strategy::ValueTree;
use proptest::test_runner::{Config, RngAlgorithm, TestRng, TestRunner};
use super::{MAX_GENERATION_RETRIES, MAX_OPS, MAX_SHRINK_MOVES, Op, any_op, replay};
use crate::{Fixture, RuleOutcome};
pub async fn ops_agree_with_the_model<F: Fixture>(open: impl AsyncFn() -> F) -> RuleOutcome {
let strategy = proptest::collection::vec(any_op(), 1..=MAX_OPS);
let config = Config::default();
let cases = config.cases;
let mut runner =
TestRunner::new_with_rng(config, TestRng::deterministic_rng(RngAlgorithm::ChaCha));
for _ in 0..cases {
let Some(mut tree) = new_tree(&strategy, &mut runner) else {
continue;
};
let Some(failure) = replay(&open, &tree.current()).await else {
continue;
};
let (ops, failure) = shrink(&open, &mut tree, failure).await;
panic!(
"the store disagreed with the model.\n\
\n\
smallest failing sequence ({} op(s)):\n{}\n\
\n\
{failure}",
ops.len(),
numbered(&ops),
);
}
RuleOutcome::Ran
}
fn new_tree<S: Strategy>(strategy: &S, runner: &mut TestRunner) -> Option<S::Tree> {
(0..MAX_GENERATION_RETRIES).find_map(|_| strategy.new_tree(runner).ok())
}
async fn shrink<F, O, T>(open: &O, tree: &mut T, failure: String) -> (Vec<Op>, String)
where
F: Fixture,
O: AsyncFn() -> F,
T: ValueTree<Value = Vec<Op>>,
{
let mut smallest = (tree.current(), failure);
let mut failing = true;
for _ in 0..MAX_SHRINK_MOVES {
let moved = if failing {
tree.simplify()
} else {
tree.complicate()
};
if !moved {
break;
}
let ops = tree.current();
match replay(open, &ops).await {
Some(failure) => {
smallest = (ops, failure);
failing = true;
}
None => failing = false,
}
}
smallest
}
fn numbered(ops: &[Op]) -> String {
ops.iter()
.enumerate()
.map(|(index, op)| format!(" {index}. {op:?}"))
.collect::<Vec<_>>()
.join("\n")
}
}
#[macro_export]
macro_rules! for_each_model_rule {
($($callback:tt)+) => {
$($callback)+! {
ops_agree_with_the_model,
}
};
}
#[macro_export]
macro_rules! emit_model_tokio {
($($name:ident),* $(,)?) => {
$(
#[tokio::test]
async fn $name() {
$crate::__private::model_rules::$name(__conformance_fixture)
.await
.report(::core::stringify!($name));
}
)*
};
}
#[macro_export]
macro_rules! emit_model_blocking {
($($name:ident),* $(,)?) => {
$(
#[test]
fn $name() {
$crate::__private::block_on($crate::__private::model_rules::$name(__conformance_fixture))
.report(::core::stringify!($name));
}
)*
};
}
#[macro_export]
macro_rules! event_store_model_conformance {
(mod_name = $mod_name:ident, emit = $emit:path, fixture = $fixture:expr) => {
mod $mod_name {
#![allow(clippy::unwrap_used, unused_imports)]
use super::*;
async fn __conformance_fixture() -> impl $crate::__private::Fixture {
$fixture
}
$crate::for_each_model_rule!($emit);
}
};
(mod_name = $mod_name:ident, fixture = $fixture:expr) => {
$crate::event_store_model_conformance!(
mod_name = $mod_name,
emit = $crate::emit_model_tokio,
fixture = $fixture
);
};
($fixture:expr) => {
$crate::event_store_model_conformance!(
mod_name = dcb_model_conformance,
emit = $crate::emit_model_tokio,
fixture = $fixture
);
};
}