use std::{sync::Arc, time::Duration};
use datum_persistence::{
Effect, EventSourcedBehavior, EventSourcedRuntime, IdentityAdapter, MemoryDurableStateStore,
MemoryJournal, PersistenceError, PersistenceId, PersistenceResult, PersistenceSerializer,
SequenceNr, SerializerCatalog, SerializerId,
query::{EventsByPersistenceIdQuery, QueryMode, decode_envelopes, into_source},
testkit::{
assert_durable_state_changes_query_conformance,
assert_events_by_persistence_id_query_conformance, assert_events_by_tag_query_conformance,
assert_persistence_ids_query_conformance,
},
};
use tokio::time::timeout;
const WAIT: Duration = Duration::from_secs(2);
#[derive(Clone, Copy)]
struct I64Serializer;
impl PersistenceSerializer<i64> for I64Serializer {
fn serializer_id(&self) -> SerializerId {
SerializerId::new(41)
}
fn manifest(&self, _value: &i64) -> String {
"query-i64-v1".into()
}
fn serialize(&self, value: &i64) -> PersistenceResult<Vec<u8>> {
Ok(value.to_be_bytes().to_vec())
}
fn deserialize(&self, manifest: &str, payload: &[u8]) -> PersistenceResult<i64> {
if manifest != "query-i64-v1" || payload.len() != 8 {
return Err(PersistenceError::Serialization(
"invalid query i64 frame".into(),
));
}
let mut bytes = [0_u8; 8];
bytes.copy_from_slice(payload);
Ok(i64::from_be_bytes(bytes))
}
}
fn catalog() -> SerializerCatalog<i64> {
SerializerCatalog::new(I64Serializer)
}
#[tokio::test]
async fn memory_events_by_persistence_id_passes_query_conformance() -> PersistenceResult<()> {
let journal = MemoryJournal::new();
assert_events_by_persistence_id_query_conformance(&journal, &journal).await
}
#[tokio::test]
async fn memory_events_by_tag_passes_query_conformance() -> PersistenceResult<()> {
let journal = MemoryJournal::new();
assert_events_by_tag_query_conformance(&journal, &journal).await
}
#[tokio::test]
async fn memory_persistence_ids_pass_query_conformance() -> PersistenceResult<()> {
let journal = MemoryJournal::new();
assert_persistence_ids_query_conformance(&journal, &journal).await
}
#[tokio::test]
async fn memory_durable_changes_pass_query_conformance() -> PersistenceResult<()> {
let durable_state = MemoryDurableStateStore::new();
assert_durable_state_changes_query_conformance(&durable_state, &durable_state).await
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn persisted_events_flow_through_live_source_and_decode_to_domain() {
let persistence_id = PersistenceId::new("query-e2e", "counter").unwrap();
let journal = Arc::new(MemoryJournal::new());
let behavior = EventSourcedBehavior::new(
persistence_id.clone(),
0_i64,
|_, events: Vec<i64>| Effect::persist_all(events),
|state: &i64, event: &i64| state + event,
)
.with_event_adapter(IdentityAdapter, catalog());
let handle = behavior
.spawn(EventSourcedRuntime::new(journal.clone()))
.await
.unwrap();
let query = journal
.events_by_persistence_id(
&persistence_id,
SequenceNr::new(1),
SequenceNr::new(3),
QueryMode::Live,
)
.await
.unwrap();
let completion = into_source(query)
.via(decode_envelopes(catalog(), IdentityAdapter))
.take(3)
.run_fold(Vec::new(), |mut events, event| {
events.push(event);
events
})
.unwrap();
handle.tell(vec![4, 5, 6]).unwrap();
let state = timeout(WAIT, handle.state())
.await
.expect("behavior state query timed out")
.expect("behavior state query failed");
assert_eq!(state.sequence_nr, SequenceNr::new(3));
let events = timeout(WAIT, completion)
.await
.expect("query Source did not collect the persisted events")
.expect("query Source failed");
assert_eq!(events, vec![4, 5, 6]);
handle.stop();
}