feat(sdk)!: support errors in mock

packages/dapi-grpc/src/mock.rs

@@ -77,12 +77,37 @@ where
 impl<T: Mockable> Mockable for Option<T> {
     #[cfg(feature = "mocks")]
     fn mock_serialize(&self) -> Option<Vec<u8>> {
-        self.as_ref().and_then(|value| value.mock_serialize())
+        let data = match self {
+            None => vec![0],
+            Some(value) => {
+                let mut data = vec![1]; // we return None if value does not support serialization
+                let mut serialized = value.mock_serialize()?;
+                data.append(&mut serialized);
+
+                data
+            }
+        };
+
+        Some(data)
     }
 
     #[cfg(feature = "mocks")]
     fn mock_deserialize(data: &[u8]) -> Option<Self> {
-        T::mock_deserialize(data).map(Some)
+        if data.is_empty() {
+            panic!("empty data");
+        }
+
+        match data[0] {
+            0 => Some(None),
+            // Mind double Some - first says mock_deserialize is implemented, second is deserialized value
+            1 => Some(Some(
+                T::mock_deserialize(&data[1..]).expect("unable to deserialize Option<T>"),
+            )),
+            _ => panic!(
+                "unsupported first byte for Option<T>::mock_deserialize: {:x}",
+                data[0]
+            ),
+        }
     }
 }
 
@@ -97,6 +122,29 @@ impl Mockable for Vec<u8> {
         serde_json::from_slice(data).ok()
     }
 }
+
+impl<T: Mockable> Mockable for Vec<T> {
+    #[cfg(feature = "mocks")]
+    fn mock_serialize(&self) -> Option<Vec<u8>> {
+        let data: Vec<Vec<u8>> = self
+            .iter()
+            .map(|d| d.mock_serialize())
+            .collect::<Option<Vec<Vec<u8>>>>()?;
+
+        Some(serde_json::to_vec(&data).expect("unable to serialize Vec<T>"))
+    }
+
+    #[cfg(feature = "mocks")]
+    fn mock_deserialize(data: &[u8]) -> Option<Self> {
+        let data: Vec<Vec<u8>> =
+            serde_json::from_slice(data).expect("unable to deserialize Vec<T>");
+
+        data.into_iter()
+            .map(|d| T::mock_deserialize(&d))
+            .collect::<Option<Vec<T>>>()
+    }
+}
+
 #[cfg(feature = "mocks")]
 #[derive(serde::Serialize, serde::Deserialize)]
 struct MockableStatus {
@@ -128,3 +176,30 @@ impl Mockable for crate::tonic::Status {
 /// This will return `None` on serialization,
 /// effectively disabling mocking of streaming responses.
 impl<T: Mockable> Mockable for Streaming<T> {}
+
+/// Mocking of primitive types - just serialize them as little-endian bytes.
+///
+/// This is useful for mocking of messages that contain primitive types.
+macro_rules! mockable_number {
+    ($($t:ty),*) => {
+        $(
+            impl Mockable for $t {
+                #[cfg(feature = "mocks")]
+                fn mock_serialize(&self) -> Option<Vec<u8>> {
+                    (*self).to_le_bytes().to_vec().mock_serialize()
+                }
+
+                #[cfg(feature = "mocks")]
+                fn mock_deserialize(data: &[u8]) -> Option<Self> {
+                    let data: Vec<u8> = Mockable::mock_deserialize(data)?;
+                    Some(Self::from_le_bytes(
+                        data.try_into().expect("invalid serialized data"),
+                    ))
+                }
+            }
+        )*
+    };
+}
+
+// No `u8` as it would cause conflict between Vec<u8> and Vec<T: Mockable>  impls.
+mockable_number!(usize, u16, u32, u64, u128, isize, i8, i16, i32, i64, i128);

packages/rs-dapi-client/Cargo.toml

@@ -5,7 +5,6 @@ edition = "2021"
 
 [features]
 default = ["mocks", "offline-testing"]
-tokio-sleep = ["backon/tokio-sleep"]
 mocks = [
     "dep:sha2",
     "dep:hex",
@@ -20,7 +19,7 @@ dump = ["mocks"]
 offline-testing = []
 
 [dependencies]
-backon = { version = "1.2"}
+backon = { version = "1.2", features = ["tokio-sleep"] }
 dapi-grpc = { path = "../dapi-grpc", features = [
     "core",
     "platform",

packages/rs-dapi-client/src/address_list.rs

@@ -1,6 +1,7 @@
 //! Subsystem to manage DAPI nodes.
 
 use chrono::Utc;
+use dapi_grpc::mock::Mockable;
 use dapi_grpc::tonic::codegen::http;
 use dapi_grpc::tonic::transport::Uri;
 use rand::{rngs::SmallRng, seq::IteratorRandom, SeedableRng};
@@ -59,6 +60,18 @@ impl From<Uri> for Address {
     }
 }
 
+impl Mockable for Address {
+    #[cfg(feature = "mocks")]
+    fn mock_serialize(&self) -> Option<Vec<u8>> {
+        Some(serde_json::to_vec(self).expect("unable to serialize Address"))
+    }
+
+    #[cfg(feature = "mocks")]
+    fn mock_deserialize(data: &[u8]) -> Option<Self> {
+        Some(serde_json::from_slice(data).expect("unable to deserialize Address"))
+    }
+}
+
 impl Address {
     /// Ban the [Address] so it won't be available through [AddressList::get_live_address] for some time.
     fn ban(&mut self, base_ban_period: &Duration) {

packages/rs-dapi-client/src/executor.rs

@@ -19,8 +19,24 @@ pub trait DapiRequestExecutor {
         <R::Client as TransportClient>::Error: Mockable;
 }
 
+/// Unwrap wrapped types
+pub trait IntoInner<T> {
+    /// Unwrap the inner type.
+    ///
+    /// This function returns inner type, dropping additional context information.
+    /// It is lossy operation, so it should be used with caution.
+    fn into_inner(self) -> T;
+}
+
+/// Convert inner type without loosing additional context information of the wrapper.
+pub trait InnerInto<T> {
+    /// Convert inner type without loosing additional context information of the wrapper.
+    fn inner_into(self) -> T;
+}
+
 /// Error happened during request execution.
 #[derive(Debug, Clone, thiserror::Error, Eq, PartialEq)]
+#[cfg_attr(feature = "mocks", derive(serde::Serialize, serde::Deserialize))]
 #[error("{inner}")]
 pub struct ExecutionError<E> {
     /// The cause of error
@@ -31,10 +47,27 @@ pub struct ExecutionError<E> {
     pub address: Option<Address>,
 }
 
-impl<E> ExecutionError<E> {
+impl<F, T> InnerInto<ExecutionError<T>> for ExecutionError<F>
+where
+    F: Into<T>,
+{
+    /// Convert inner error type without loosing retries and address
+    fn inner_into(self) -> ExecutionError<T> {
+        ExecutionError {
+            inner: self.inner.into(),
+            retries: self.retries,
+            address: self.address,
+        }
+    }
+}
+
+impl<E, I> IntoInner<I> for ExecutionError<E>
+where
+    E: Into<I>,
+{
     /// Unwrap the error cause
-    pub fn into_inner(self) -> E {
-        self.inner
+    fn into_inner(self) -> I {
+        self.inner.into()
     }
 }
 
@@ -46,6 +79,7 @@ impl<E: CanRetry> CanRetry for ExecutionError<E> {
 
 /// Request execution response.
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "mocks", derive(serde::Serialize, serde::Deserialize))]
 pub struct ExecutionResponse<R> {
     /// The response from the request
     pub inner: R,
@@ -55,12 +89,62 @@ pub struct ExecutionResponse<R> {
     pub address: Address,
 }
 
-impl<R> ExecutionResponse<R> {
+#[cfg(feature = "mocks")]
+impl<R: Default> Default for ExecutionResponse<R> {
+    fn default() -> Self {
+        Self {
+            retries: Default::default(),
+            address: "http://127.0.0.1".parse().expect("create mock address"),
+            inner: Default::default(),
+        }
+    }
+}
+
+impl<R, I> IntoInner<I> for ExecutionResponse<R>
+where
+    R: Into<I>,
+{
     /// Unwrap the response
-    pub fn into_inner(self) -> R {
-        self.inner
+    fn into_inner(self) -> I {
+        self.inner.into()
+    }
+}
+
+impl<F, T> InnerInto<ExecutionResponse<T>> for ExecutionResponse<F>
+where
+    F: Into<T>,
+{
+    /// Convert inner response type without loosing retries and address
+    fn inner_into(self) -> ExecutionResponse<T> {
+        ExecutionResponse {
+            inner: self.inner.into(),
+            retries: self.retries,
+            address: self.address,
+        }
     }
 }
 
 /// Result of request execution
 pub type ExecutionResult<R, E> = Result<ExecutionResponse<R>, ExecutionError<E>>;
+
+impl<R, E> IntoInner<Result<R, E>> for ExecutionResult<R, E> {
+    fn into_inner(self) -> Result<R, E> {
+        match self {
+            Ok(response) => Ok(response.into_inner()),
+            Err(error) => Err(error.into_inner()),
+        }
+    }
+}
+
+impl<F, FE, T, TE> InnerInto<ExecutionResult<T, TE>> for ExecutionResult<F, FE>
+where
+    F: Into<T>,
+    FE: Into<TE>,
+{
+    fn inner_into(self) -> ExecutionResult<T, TE> {
+        match self {
+            Ok(response) => Ok(response.inner_into()),
+            Err(error) => Err(error.inner_into()),
+        }
+    }
+}

packages/rs-dapi-client/src/lib.rs

@@ -21,7 +21,9 @@ pub use dapi_client::{DapiClient, DapiClientError};
 use dapi_grpc::mock::Mockable;
 #[cfg(feature = "dump")]
 pub use dump::DumpData;
-pub use executor::{DapiRequestExecutor, ExecutionError, ExecutionResponse, ExecutionResult};
+pub use executor::{
+    DapiRequestExecutor, ExecutionError, ExecutionResponse, ExecutionResult, InnerInto, IntoInner,
+};
 use futures::{future::BoxFuture, FutureExt};
 pub use request_settings::RequestSettings;