datum-persistence 0.11.3

Event sourcing, durable state, and CQRS persistence for Datum
Documentation
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();
}