#![deny(warnings)]
use mockall::*;
use serde::{Deserialize, Deserializer};
use serde_derive::*;
#[derive(Deserialize, Serialize)]
pub struct SurrogateThing {
x: u32
}
mock! {
pub Thing {
fn private_deserialize(deserializable: Result<SurrogateThing, ()>) -> Self;
fn private_serialize(&self) -> SurrogateThing;
}
}
impl serde::Serialize for MockThing {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
self.private_serialize().serialize(s)
}
}
impl<'de> Deserialize<'de> for MockThing {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let serializable = SurrogateThing::deserialize(deserializer)
.map_err(|_| ());
Ok(MockThing::private_deserialize(serializable))
}
}
#[test]
fn serialize() {
let mut mock = MockThing::default();
mock.expect_private_serialize()
.returning(|| SurrogateThing{x: 42} );
let json = serde_json::to_string(&mock).unwrap();
assert_eq!("{\"x\":42}", json);
}
#[test]
fn deserialize() {
let ctx = MockThing::private_deserialize_context();
ctx.expect()
.withf(|st: &Result<SurrogateThing, ()>|
st.as_ref().unwrap().x == 42
).once()
.returning(|_| MockThing::default());
let json = "{\"x\":42}";
let _thing: MockThing = serde_json::from_str(json).unwrap();
}