use std::{
collections::HashSet,
sync::atomic::{AtomicU8, AtomicU64, Ordering},
time::Duration,
};
use futures_util::StreamExt;
use tokio::time::timeout;
use crate::{
AppendOutcome, AtomicWrite, DurableStateStore, EventStream, Journal, PersistenceError,
PersistenceId, PersistenceResult, ReplayRange, Revision, SelectedSnapshot, SequenceNr,
SerializedPayload, SerializerId, SnapshotCriteria, SnapshotMetadata, SnapshotStore,
StoredEvent, Tag,
query::{
DurableStateChange, DurableStateChangesQuery, EventEnvelope, EventsByPersistenceIdQuery,
EventsByTagQuery, Offset, PersistenceIdsQuery, QueryMode, QueryStream,
},
};
static TEST_NAMESPACE: AtomicU64 = AtomicU64::new(1);
const QUERY_WAIT: Duration = Duration::from_secs(2);
const FAILING_JOURNAL_PASS: u8 = 0;
const FAILING_JOURNAL_FAIL_NEXT: u8 = 1;
const FAILING_JOURNAL_REJECT_NEXT: u8 = 2;
#[derive(Debug, Default)]
pub struct FailingJournal {
inner: crate::MemoryJournal,
next_append: AtomicU8,
}
impl FailingJournal {
#[must_use]
pub fn new() -> Self {
Self::default()
}
pub fn fail_next_append(&self) {
self.next_append
.store(FAILING_JOURNAL_FAIL_NEXT, Ordering::Release);
}
pub fn reject_next_append(&self) {
self.next_append
.store(FAILING_JOURNAL_REJECT_NEXT, Ordering::Release);
}
}
#[async_trait::async_trait]
impl Journal for FailingJournal {
async fn append(&self, writes: Vec<AtomicWrite>) -> PersistenceResult<Vec<AppendOutcome>> {
match self
.next_append
.swap(FAILING_JOURNAL_PASS, Ordering::AcqRel)
{
FAILING_JOURNAL_FAIL_NEXT => Err(PersistenceError::Failure(
"injected journal append failure".into(),
)),
FAILING_JOURNAL_REJECT_NEXT => Ok(writes
.into_iter()
.map(|_| AppendOutcome::Rejected {
reason: "injected journal append rejection".into(),
})
.collect()),
_ => self.inner.append(writes).await,
}
}
async fn highest_sequence_nr(
&self,
persistence_id: &PersistenceId,
from_hint: SequenceNr,
) -> PersistenceResult<SequenceNr> {
self.inner
.highest_sequence_nr(persistence_id, from_hint)
.await
}
async fn replay(&self, range: ReplayRange) -> PersistenceResult<EventStream> {
self.inner.replay(range).await
}
async fn delete_to(
&self,
persistence_id: &PersistenceId,
inclusive: SequenceNr,
) -> PersistenceResult<()> {
self.inner.delete_to(persistence_id, inclusive).await
}
}
pub async fn assert_journal_conformance(journal: &dyn Journal) -> PersistenceResult<()> {
let namespace = TEST_NAMESPACE.fetch_add(1, Ordering::Relaxed);
let unknown_id = test_id("journal-unknown", namespace);
assert_eq!(
journal
.highest_sequence_nr(&unknown_id, SequenceNr::new(99))
.await?,
SequenceNr::new(0),
"an unknown persistence id must have watermark zero regardless of the hint"
);
assert!(matches!(
AtomicWrite::new(Vec::new()),
Err(PersistenceError::InvalidAtomicWrite(_))
));
let mismatched_id = test_id("journal-mismatched", namespace);
assert!(matches!(
AtomicWrite::new(vec![event(&unknown_id, 1, 1), event(&mismatched_id, 2, 2),]),
Err(PersistenceError::InvalidAtomicWrite(_))
));
assert!(matches!(
AtomicWrite::new(vec![event(&unknown_id, 1, 1), event(&unknown_id, 3, 3),]),
Err(PersistenceError::InvalidAtomicWrite(_))
));
let ordered_id = test_id("journal-ordered", namespace);
let outcomes = journal
.append(vec![
atomic(vec![
event(&ordered_id, 1, 1),
event(&ordered_id, 2, 2),
event(&ordered_id, 3, 3),
]),
atomic(vec![event(&ordered_id, 4, 4)]),
atomic(vec![event(&ordered_id, 5, 5)]),
])
.await?;
assert_eq!(
outcomes.len(),
3,
"append must return one outcome per input"
);
assert!(
outcomes
.iter()
.all(|outcome| *outcome == AppendOutcome::Accepted),
"valid sequential writes must be accepted"
);
let all = replay(journal, replay_range(&ordered_id, 1, 5, u64::MAX)).await?;
assert_sequence_nrs(&all, &[1, 2, 3, 4, 5]);
assert_eq!(
all[1].metadata,
Some(payload(102)),
"journal replay must preserve optional metadata frames"
);
assert_eq!(all[1].tags, vec![Tag::new("even")]);
let bounded = replay(journal, replay_range(&ordered_id, 2, 4, u64::MAX)).await?;
assert_sequence_nrs(&bounded, &[2, 3, 4]);
let limited = replay(journal, replay_range(&ordered_id, 2, 5, 2)).await?;
assert_sequence_nrs(&limited, &[2, 3]);
assert!(
replay(journal, replay_range(&ordered_id, 5, 4, u64::MAX))
.await?
.is_empty(),
"reversed replay bounds must be empty"
);
assert!(
replay(journal, replay_range(&ordered_id, 1, 5, 0))
.await?
.is_empty(),
"replay max zero must be empty"
);
journal.delete_to(&ordered_id, SequenceNr::new(3)).await?;
assert_sequence_nrs(
&replay(journal, replay_range(&ordered_id, 1, 5, u64::MAX)).await?,
&[4, 5],
);
assert_eq!(
journal
.highest_sequence_nr(&ordered_id, SequenceNr::new(0))
.await?,
SequenceNr::new(5),
"the high watermark must survive a prefix delete"
);
journal
.delete_to(&ordered_id, SequenceNr::new(u64::MAX))
.await?;
assert!(
replay(journal, replay_range(&ordered_id, 1, u64::MAX, u64::MAX))
.await?
.is_empty(),
"delete-to-MAX must hide the entire stored range"
);
assert_eq!(
journal
.highest_sequence_nr(&ordered_id, SequenceNr::new(u64::MAX))
.await?,
SequenceNr::new(5),
"the high watermark must survive delete-to-MAX"
);
assert_eq!(
journal
.append(vec![atomic(vec![event(&ordered_id, 6, 6)])])
.await?,
vec![AppendOutcome::Accepted],
"a delete-to-MAX must not hide later events above the preserved watermark"
);
assert_sequence_nrs(
&replay(journal, replay_range(&ordered_id, 1, u64::MAX, u64::MAX)).await?,
&[6],
);
let rejected_id = test_id("journal-rejected", namespace);
assert_eq!(
journal
.append(vec![atomic(vec![event(&rejected_id, 1, 10)])])
.await?,
vec![AppendOutcome::Accepted]
);
let sibling_id = test_id("journal-sibling", namespace);
let outcomes = journal
.append(vec![
atomic(vec![event(&rejected_id, 3, 30), event(&rejected_id, 4, 40)]),
atomic(vec![event(&sibling_id, 1, 50), event(&sibling_id, 2, 60)]),
])
.await?;
assert_eq!(
outcomes.len(),
2,
"append must return one outcome per input"
);
assert!(matches!(
&outcomes[0],
AppendOutcome::Rejected { reason } if !reason.is_empty()
));
assert_eq!(outcomes[1], AppendOutcome::Accepted);
assert_sequence_nrs(
&replay(journal, replay_range(&rejected_id, 1, u64::MAX, u64::MAX)).await?,
&[1],
);
assert_sequence_nrs(
&replay(journal, replay_range(&sibling_id, 1, u64::MAX, u64::MAX)).await?,
&[1, 2],
);
Ok(())
}
pub async fn assert_snapshot_store_conformance(
snapshots: &dyn SnapshotStore,
) -> PersistenceResult<()> {
let namespace = TEST_NAMESPACE.fetch_add(1, Ordering::Relaxed);
let persistence_id = test_id("snapshot", namespace);
assert!(
snapshots
.load(&persistence_id, &SnapshotCriteria::latest())
.await?
.is_none(),
"snapshot absence must be returned as None, not a load failure"
);
assert!(
snapshots
.load(&persistence_id, &SnapshotCriteria::none())
.await?
.is_none(),
"SnapshotCriteria::none must never select a snapshot"
);
for (sequence_nr, timestamp_ms, marker) in [(1, 100, 1), (3, 300, 3), (2, 200, 2)] {
snapshots
.save(
snapshot_metadata(&persistence_id, sequence_nr, timestamp_ms),
format!("datum-tck-state-adapter-v{marker}"),
payload(marker),
)
.await?;
}
let latest = require_snapshot(
snapshots
.load(&persistence_id, &SnapshotCriteria::latest())
.await?,
);
assert_eq!(latest.metadata.sequence_nr, SequenceNr::new(3));
assert_eq!(latest.adapter_manifest, "datum-tck-state-adapter-v3");
assert_eq!(latest.state, payload(3));
let exact_two = SnapshotCriteria {
min_sequence_nr: SequenceNr::new(2),
max_sequence_nr: SequenceNr::new(2),
min_timestamp_ms: 200,
max_timestamp_ms: 200,
};
assert_eq!(
require_snapshot(snapshots.load(&persistence_id, &exact_two).await?).state,
payload(2),
"all snapshot criteria bounds must be inclusive"
);
let replacement = snapshot_metadata(&persistence_id, 3, 350);
snapshots
.save(
replacement.clone(),
"datum-tck-state-adapter-v33".into(),
payload(33),
)
.await?;
let latest = require_snapshot(
snapshots
.load(&persistence_id, &SnapshotCriteria::latest())
.await?,
);
assert_eq!(latest.metadata, replacement);
assert_eq!(latest.adapter_manifest, "datum-tck-state-adapter-v33");
assert_eq!(latest.state, payload(33));
snapshots
.delete(snapshot_metadata(&persistence_id, 3, 300))
.await?;
assert_eq!(
require_snapshot(
snapshots
.load(&persistence_id, &SnapshotCriteria::latest())
.await?,
)
.state,
payload(33),
"deleting replaced metadata must not remove the current same-sequence snapshot"
);
snapshots
.delete(snapshot_metadata(&persistence_id, 2, 200))
.await?;
assert!(snapshots.load(&persistence_id, &exact_two).await?.is_none());
for (sequence_nr, timestamp_ms) in [(4, 400), (5, 500), (6, 600)] {
snapshots
.save(
snapshot_metadata(&persistence_id, sequence_nr, timestamp_ms),
format!("datum-tck-state-adapter-v{sequence_nr}"),
payload(sequence_nr),
)
.await?;
}
let delete_range = SnapshotCriteria {
min_sequence_nr: SequenceNr::new(4),
max_sequence_nr: SequenceNr::new(5),
min_timestamp_ms: 400,
max_timestamp_ms: 500,
};
snapshots
.delete_matching(&persistence_id, &delete_range)
.await?;
assert!(
snapshots
.load(&persistence_id, &delete_range)
.await?
.is_none(),
"delete_matching must remove every snapshot inside the inclusive criteria"
);
assert_eq!(
require_snapshot(
snapshots
.load(&persistence_id, &SnapshotCriteria::latest())
.await?,
)
.metadata
.sequence_nr,
SequenceNr::new(6),
"delete_matching must preserve snapshots outside its criteria"
);
Ok(())
}
pub async fn assert_durable_state_store_conformance(
durable_state: &dyn DurableStateStore,
) -> PersistenceResult<()> {
let namespace = TEST_NAMESPACE.fetch_add(1, Ordering::Relaxed);
let persistence_id = test_id("durable", namespace);
let absent = durable_state.get(&persistence_id).await?;
assert_eq!(absent.revision, Revision::new(0));
assert!(
absent.state.is_none(),
"unknown durable state must be absent"
);
let invalid_first_revision = durable_state
.upsert(&persistence_id, Revision::new(2), payload(2), None)
.await
.expect_err("the first durable-state write must use revision one");
assert!(matches!(
invalid_first_revision,
PersistenceError::RevisionConflict {
expected,
actual,
..
} if expected == Revision::new(1) && actual == Revision::new(2)
));
assert_eq!(durable_state.get(&persistence_id).await?, absent);
durable_state
.upsert(
&persistence_id,
Revision::new(1),
payload(1),
Some(Tag::new("blue")),
)
.await?;
let first = durable_state.get(&persistence_id).await?;
assert_eq!(first.revision, Revision::new(1));
assert_eq!(first.state, Some(payload(1)));
assert_eq!(first.tag, Some(Tag::new("blue")));
let conflict = durable_state
.upsert(&persistence_id, Revision::new(3), payload(3), None)
.await
.expect_err("a skipped durable-state revision must conflict");
assert!(matches!(
conflict,
PersistenceError::RevisionConflict {
persistence_id: ref conflict_id,
expected,
actual,
} if conflict_id == &persistence_id
&& expected == Revision::new(2)
&& actual == Revision::new(3)
));
assert_eq!(
durable_state.get(&persistence_id).await?,
first,
"a CAS conflict must not change stored durable state"
);
durable_state
.upsert(&persistence_id, Revision::new(2), payload(2), None)
.await?;
assert_eq!(durable_state.get(&persistence_id).await?.tag, None);
durable_state
.delete(&persistence_id, Revision::new(3))
.await?;
let tombstone = durable_state.get(&persistence_id).await?;
assert_eq!(tombstone.revision, Revision::new(3));
assert!(
tombstone.state.is_none(),
"delete must leave an absent-state tombstone at the advanced revision"
);
assert_eq!(
tombstone.tag, None,
"delete must clear the durable-state tag"
);
let stale_delete = durable_state
.delete(&persistence_id, Revision::new(3))
.await
.expect_err("reusing the tombstone revision must conflict");
assert!(matches!(
stale_delete,
PersistenceError::RevisionConflict {
expected,
actual,
..
} if expected == Revision::new(4) && actual == Revision::new(3)
));
assert_eq!(durable_state.get(&persistence_id).await?, tombstone);
Ok(())
}
pub async fn assert_events_by_persistence_id_query_conformance(
journal: &dyn Journal,
query: &dyn EventsByPersistenceIdQuery,
) -> PersistenceResult<()> {
let namespace = TEST_NAMESPACE.fetch_add(1, Ordering::Relaxed);
let persistence_id = test_id("query-pid-bounds", namespace);
append_accepted(
journal,
vec![
event(&persistence_id, 1, 1),
event(&persistence_id, 2, 2),
event(&persistence_id, 3, 3),
event(&persistence_id, 4, 4),
event(&persistence_id, 5, 5),
],
)
.await?;
let bounded = collect_query(
query
.events_by_persistence_id(
&persistence_id,
SequenceNr::new(2),
SequenceNr::new(4),
QueryMode::Current,
)
.await?,
"current per-id inclusive range",
)
.await?;
assert_envelope_sequence_nrs(&bounded, &[2, 3, 4]);
let current_at_boundary = query
.events_by_persistence_id(
&persistence_id,
SequenceNr::new(1),
SequenceNr::new(6),
QueryMode::Current,
)
.await?;
append_accepted(journal, vec![event(&persistence_id, 6, 6)]).await?;
let boundary_events = collect_query(current_at_boundary, "current per-id boundary").await?;
assert_envelope_sequence_nrs(&boundary_events, &[1, 2, 3, 4, 5]);
let live_id = test_id("query-pid-live", namespace);
append_accepted(journal, vec![event(&live_id, 1, 11)]).await?;
let mut live = query
.events_by_persistence_id(
&live_id,
SequenceNr::new(1),
SequenceNr::new(3),
QueryMode::Live,
)
.await?;
let first = require_query_item(&mut live, "initial live per-id event").await?;
assert_eq!(first.sequence_nr, SequenceNr::new(1));
append_accepted(
journal,
vec![event(&live_id, 2, 12), event(&live_id, 3, 13)],
)
.await?;
let second = require_query_item(&mut live, "second live per-id event").await?;
let third = require_query_item(&mut live, "third live per-id event").await?;
assert_eq!(second.sequence_nr, SequenceNr::new(2));
assert_eq!(third.sequence_nr, SequenceNr::new(3));
assert!(
next_query_item(&mut live, "finite live per-id completion")
.await?
.is_none(),
"a live per-id query must complete after its finite inclusive upper bound"
);
Ok(())
}
pub async fn assert_events_by_tag_query_conformance(
journal: &dyn Journal,
query: &dyn EventsByTagQuery,
) -> PersistenceResult<()> {
let namespace = TEST_NAMESPACE.fetch_add(1, Ordering::Relaxed);
let tag = Tag::new(format!("query-order-{namespace}"));
let first_id = test_id("query-tag-first", namespace);
let second_id = test_id("query-tag-second", namespace);
append_accepted(journal, vec![tagged_event(&first_id, 1, 101, &tag)]).await?;
append_accepted(journal, vec![tagged_event(&second_id, 1, 102, &tag)]).await?;
append_accepted(journal, vec![tagged_event(&first_id, 2, 103, &tag)]).await?;
let ordered = collect_query(
query
.events_by_tag(&tag, Offset::NoOffset, QueryMode::Current)
.await?,
"current tag ordering",
)
.await?;
assert_eq!(
ordered
.iter()
.map(|envelope| (&envelope.persistence_id, envelope.sequence_nr.as_u64()))
.collect::<Vec<_>>(),
vec![(&first_id, 1), (&second_id, 1), (&first_id, 2)],
"tag queries must preserve the backend's global append order"
);
assert_strict_sequence_offsets(&ordered);
let resume_tag = Tag::new(format!("query-resume-{namespace}"));
let resume_id = test_id("query-tag-resume", namespace);
append_accepted(
journal,
vec![
tagged_event(&resume_id, 1, 201, &resume_tag),
tagged_event(&resume_id, 2, 202, &resume_tag),
tagged_event(&resume_id, 3, 203, &resume_tag),
],
)
.await?;
let mut disconnected = query
.events_by_tag(&resume_tag, Offset::NoOffset, QueryMode::Live)
.await?;
let first = require_query_item(&mut disconnected, "first pre-disconnect tag event").await?;
let second = require_query_item(&mut disconnected, "second pre-disconnect tag event").await?;
let resume_offset = second.offset;
drop(disconnected);
append_accepted(journal, vec![tagged_event(&resume_id, 4, 204, &resume_tag)]).await?;
let resumed = collect_query(
query
.events_by_tag(&resume_tag, resume_offset, QueryMode::Current)
.await?,
"resumed current tag query",
)
.await?;
let observed = std::iter::once(first)
.chain(std::iter::once(second))
.chain(resumed)
.filter(|envelope| envelope.persistence_id == resume_id)
.map(|envelope| envelope.sequence_nr.as_u64())
.collect::<HashSet<_>>();
assert_eq!(
observed,
HashSet::from([1, 2, 3, 4]),
"resuming from the last observed offset must not lose unseen tag events"
);
Ok(())
}
pub async fn assert_persistence_ids_query_conformance(
journal: &dyn Journal,
query: &dyn PersistenceIdsQuery,
) -> PersistenceResult<()> {
let namespace = TEST_NAMESPACE.fetch_add(1, Ordering::Relaxed);
let first_id = test_id("query-ids-first", namespace);
let second_id = test_id("query-ids-second", namespace);
let third_id = test_id("query-ids-third", namespace);
append_accepted(journal, vec![event(&first_id, 1, 301)]).await?;
let current_at_boundary = query.persistence_ids(QueryMode::Current).await?;
append_accepted(journal, vec![event(&second_id, 1, 302)]).await?;
let current = collect_query(current_at_boundary, "current persistence ids boundary").await?;
assert!(current.contains(&first_id));
assert!(
!current.contains(&second_id),
"Current persistence_ids must exclude ids first written after its boundary"
);
let mut live = query.persistence_ids(QueryMode::Live).await?;
let initial_count = 2;
let mut initial = Vec::with_capacity(initial_count);
for _ in 0..initial_count {
initial.push(require_query_item(&mut live, "initial live persistence id").await?);
}
assert!(initial.contains(&first_id));
assert!(initial.contains(&second_id));
append_accepted(journal, vec![event(&third_id, 1, 303)]).await?;
assert_eq!(
require_query_item(&mut live, "later live persistence id").await?,
third_id
);
Ok(())
}
pub async fn assert_durable_state_changes_query_conformance(
durable_state: &dyn DurableStateStore,
query: &dyn DurableStateChangesQuery,
) -> PersistenceResult<()> {
let namespace = TEST_NAMESPACE.fetch_add(1, Ordering::Relaxed);
let tag = Tag::new(format!("query-durable-{namespace}"));
let persistence_id = test_id("query-durable", namespace);
for revision in 1..=3 {
durable_state
.upsert(
&persistence_id,
Revision::new(revision),
payload(revision),
Some(tag.clone()),
)
.await?;
}
let current = collect_query(
query
.changes(&tag, Offset::NoOffset, QueryMode::Current)
.await?,
"current durable-state changes",
)
.await?;
let matching = current
.iter()
.filter(|change| change.persistence_id() == &persistence_id)
.collect::<Vec<_>>();
assert_eq!(
matching.len(),
1,
"Current durable changes must coalesce to one latest value per id"
);
assert_eq!(matching[0].revision(), Revision::new(3));
assert!(matches!(matching[0], DurableStateChange::Updated(_)));
let mut live = query
.changes(&tag, Offset::NoOffset, QueryMode::Live)
.await?;
let initial = require_query_item(&mut live, "initial live durable change").await?;
assert_eq!(initial.revision(), Revision::new(3));
for revision in 4..=6 {
durable_state
.upsert(
&persistence_id,
Revision::new(revision),
payload(revision),
Some(tag.clone()),
)
.await?;
}
let latest = timeout(QUERY_WAIT, async {
loop {
match live.next().await {
Some(Ok(change)) if change.persistence_id() == &persistence_id => {
if change.revision() == Revision::new(6) {
break Ok(change);
}
}
Some(Ok(_)) => {}
Some(Err(error)) => break Err(error),
None => {
break Err(PersistenceError::Failure(
"live durable query completed before the latest revision".into(),
));
}
}
}
})
.await
.map_err(|_| PersistenceError::Failure("latest durable revision timed out".into()))??;
let resume_offset = latest.offset();
drop(live);
durable_state
.delete(&persistence_id, Revision::new(7))
.await?;
let resumed = collect_query(
query
.changes(&tag, resume_offset, QueryMode::Current)
.await?,
"resumed durable-state changes",
)
.await?;
assert!(
resumed.iter().any(|change| {
matches!(
change,
DurableStateChange::Deleted(deleted)
if deleted.persistence_id == persistence_id
&& deleted.revision == Revision::new(7)
)
}),
"resuming after the latest observed durable offset must expose the later tombstone"
);
Ok(())
}
fn test_id(kind: &str, namespace: u64) -> PersistenceId {
PersistenceId::new("datum-tck", format!("{kind}-{namespace}"))
.expect("conformance-suite ids are valid")
}
fn payload(marker: u64) -> SerializedPayload {
SerializedPayload::new(
SerializerId::new(7),
"datum-tck-v1",
marker.to_be_bytes().to_vec(),
)
}
fn event(persistence_id: &PersistenceId, sequence_nr: u64, marker: u64) -> StoredEvent {
let is_even = sequence_nr & 1 == 0;
StoredEvent {
persistence_id: persistence_id.clone(),
sequence_nr: SequenceNr::new(sequence_nr),
adapter_manifest: "datum-tck-adapter-v1".to_owned(),
writer_uuid: "datum-tck-writer".to_owned(),
timestamp_ms: i64::try_from(marker).expect("test marker fits i64"),
metadata: is_even.then(|| payload(marker + 100)),
payload: payload(marker),
tags: is_even.then(|| Tag::new("even")).into_iter().collect(),
}
}
fn tagged_event(
persistence_id: &PersistenceId,
sequence_nr: u64,
marker: u64,
tag: &Tag,
) -> StoredEvent {
let mut event = event(persistence_id, sequence_nr, marker);
event.tags = vec![tag.clone()];
event
}
fn atomic(events: Vec<StoredEvent>) -> AtomicWrite {
AtomicWrite::new(events).expect("conformance-suite writes are internally valid")
}
fn replay_range(persistence_id: &PersistenceId, from: u64, to: u64, max: u64) -> ReplayRange {
ReplayRange {
persistence_id: persistence_id.clone(),
from: SequenceNr::new(from),
to: SequenceNr::new(to),
max,
}
}
async fn replay(journal: &dyn Journal, range: ReplayRange) -> PersistenceResult<Vec<StoredEvent>> {
let stream = journal.replay(range).await?;
collect_events(stream).await
}
async fn collect_events(mut stream: EventStream) -> PersistenceResult<Vec<StoredEvent>> {
let mut events = Vec::new();
while let Some(event) = stream.next().await {
events.push(event?);
}
Ok(events)
}
async fn append_accepted(journal: &dyn Journal, events: Vec<StoredEvent>) -> PersistenceResult<()> {
let outcome = journal.append_one(atomic(events)).await?;
assert_eq!(
outcome,
AppendOutcome::Accepted,
"conformance-suite setup writes must be accepted"
);
Ok(())
}
async fn collect_query<T>(stream: QueryStream<T>, context: &str) -> PersistenceResult<Vec<T>> {
timeout(QUERY_WAIT, async move {
let mut stream = stream;
let mut items = Vec::new();
while let Some(item) = stream.next().await {
items.push(item?);
}
Ok(items)
})
.await
.map_err(|_| PersistenceError::Failure(format!("{context} timed out")))?
}
async fn next_query_item<T>(
stream: &mut QueryStream<T>,
context: &str,
) -> PersistenceResult<Option<T>> {
timeout(QUERY_WAIT, stream.next())
.await
.map_err(|_| PersistenceError::Failure(format!("{context} timed out")))?
.transpose()
}
async fn require_query_item<T>(stream: &mut QueryStream<T>, context: &str) -> PersistenceResult<T> {
next_query_item(stream, context).await?.ok_or_else(|| {
PersistenceError::Failure(format!("{context} completed without an expected item"))
})
}
fn assert_sequence_nrs(events: &[StoredEvent], expected: &[u64]) {
let actual = events
.iter()
.map(|event| event.sequence_nr.as_u64())
.collect::<Vec<_>>();
assert_eq!(actual, expected, "replay sequence numbers differ");
}
fn assert_envelope_sequence_nrs(events: &[EventEnvelope], expected: &[u64]) {
let actual = events
.iter()
.map(|event| event.sequence_nr.as_u64())
.collect::<Vec<_>>();
assert_eq!(actual, expected, "query sequence numbers differ");
}
fn assert_strict_sequence_offsets(events: &[EventEnvelope]) {
let mut sequences = Vec::new();
let mut timestamps = Vec::new();
for event in events {
match event.offset {
Offset::Sequence(offset) => sequences.push(offset),
Offset::Timestamp {
epoch_micros,
seq_nr,
} => timestamps.push((epoch_micros, seq_nr)),
other => panic!("an emitted event must carry a concrete offset, got {other:?}"),
}
}
assert!(
sequences.is_empty() || timestamps.is_empty(),
"a backend must not mix offset kinds in one stream"
);
assert!(
sequences.windows(2).all(|pair| pair[0] < pair[1]),
"tag-query sequence offsets must follow strict global append order: {sequences:?}"
);
assert!(
timestamps.windows(2).all(|pair| pair[0] <= pair[1]),
"tag-query timestamp offsets must be non-decreasing: {timestamps:?}"
);
}
fn snapshot_metadata(
persistence_id: &PersistenceId,
sequence_nr: u64,
timestamp_ms: i64,
) -> SnapshotMetadata {
SnapshotMetadata {
persistence_id: persistence_id.clone(),
sequence_nr: SequenceNr::new(sequence_nr),
timestamp_ms,
}
}
fn require_snapshot(snapshot: Option<SelectedSnapshot>) -> SelectedSnapshot {
snapshot.expect("a matching saved snapshot must be returned")
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{MemoryDurableStateStore, MemoryJournal, MemorySnapshotStore};
#[tokio::test]
async fn memory_backends_pass_the_public_conformance_suite() -> PersistenceResult<()> {
assert_journal_conformance(&MemoryJournal::new()).await?;
assert_snapshot_store_conformance(&MemorySnapshotStore::new()).await?;
assert_durable_state_store_conformance(&MemoryDurableStateStore::new()).await?;
Ok(())
}
struct FailingSnapshotStore;
#[async_trait::async_trait]
impl SnapshotStore for FailingSnapshotStore {
async fn load(
&self,
_persistence_id: &PersistenceId,
_criteria: &SnapshotCriteria,
) -> PersistenceResult<Option<SelectedSnapshot>> {
Err(PersistenceError::Failure(
"injected snapshot load failure".to_owned(),
))
}
async fn save(
&self,
_metadata: SnapshotMetadata,
_adapter_manifest: String,
_state: SerializedPayload,
) -> PersistenceResult<()> {
Ok(())
}
async fn delete(&self, _metadata: SnapshotMetadata) -> PersistenceResult<()> {
Ok(())
}
async fn delete_matching(
&self,
_persistence_id: &PersistenceId,
_criteria: &SnapshotCriteria,
) -> PersistenceResult<()> {
Ok(())
}
}
#[tokio::test]
async fn snapshot_conformance_does_not_treat_load_failure_as_absence() {
let error = assert_snapshot_store_conformance(&FailingSnapshotStore)
.await
.expect_err("the injected load failure must propagate");
assert!(
matches!(error, PersistenceError::Failure(message) if message.contains("injected"))
);
}
}