Function cqrs_proptest::roundtrip_through_serialization

pub fn roundtrip_through_serialization<E: SerializableEvent + DeserializableEvent>(
    original: &E
) -> E

Given a serializable event, constructs a buffer, serializes the event to the buffer, and then deserializes the event, returning the deserialized value.

Examples

use cqrs_core::{Event, SerializableEvent, DeserializableEvent};
use cqrs_proptest::roundtrip_through_serialization;
use serde::{Serialize, Deserialize};

#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
struct CreatedEvent{};

impl Event for CreatedEvent {
    fn event_type(&self) -> &'static str {
        "created"
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
struct DeletedEvent{};

impl Event for DeletedEvent {
    fn event_type(&self) -> &'static str {
        "deleted"
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum MyEvents {
    Created(CreatedEvent),
    Deleted(DeletedEvent),
}

impl Event for MyEvents {
    fn event_type(&self) -> &'static str {
        match *self {
            MyEvents::Created(ref e) => e.event_type(),
            MyEvents::Deleted(ref e) => e.event_type(),
        }
    }
}

impl SerializableEvent for MyEvents {
    type Error = serde_json::Error;

    fn serialize_event_to_buffer(&self, buffer: &mut Vec<u8>) -> Result<(), Self::Error> {
        match *self {
            MyEvents::Created(ref e) => serde_json::to_writer(buffer, e),
            MyEvents::Deleted(ref e) => serde_json::to_writer(buffer, e),
        }
    }
}

impl DeserializableEvent for MyEvents {
    type Error = serde_json::Error;

    fn deserialize_event_from_buffer(buffer: &[u8], event_type: &str) -> Result<Option<Self>, Self::Error> {
        match event_type {
            "created" => serde_json::from_reader(buffer).map(MyEvents::Created).map(Some),
            "deleted" => serde_json::from_reader(buffer).map(MyEvents::Deleted).map(Some),
            _ => Ok(None),
        }
    }
}

let original = MyEvents::Created(CreatedEvent{});
let roundtrip = roundtrip_through_serialization(&original);
assert_eq!(original, roundtrip);