feat(sdk)!: support errors in mock

packages/dapi-grpc/src/mock.rs

@@ -26,19 +26,18 @@ where
     /// # Panics
     ///
     /// Panics on any error.
-    fn mock_serialize(&self) -> Option<Vec<u8>> {
-        None
-    }
+    #[cfg(feature = "mocks")]
+    fn mock_serialize(&self) -> Option<Vec<u8>>;
+
     /// Deserialize the message serialized with [mock_serialize()].
     ///
     /// Returns None if the message is not serializable or mocking is disabled.
     ///
     /// # Panics
     ///
     /// Panics on any error.
-    fn mock_deserialize(_data: &[u8]) -> Option<Self> {
-        None
-    }
+    #[cfg(feature = "mocks")]
+    fn mock_deserialize(_data: &[u8]) -> Option<Self>;
 }
 #[cfg(feature = "mocks")]
 #[derive(serde::Serialize, serde::Deserialize)]
@@ -77,12 +76,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 +121,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 {
@@ -127,4 +174,41 @@ 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> {}
+impl<T: Mockable> Mockable for Streaming<T> {
+    #[cfg(feature = "mocks")]
+    fn mock_serialize(&self) -> Option<Vec<u8>> {
+        unimplemented!("mocking of streaming messages is not supported")
+    }
+
+    #[cfg(feature = "mocks")]
+    fn mock_deserialize(_data: &[u8]) -> Option<Self> {
+        unimplemented!("mocking of streaming messages is not supported")
+    }
+}
+
+/// 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/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/dapi_client.rs

@@ -11,9 +11,8 @@ use tracing::Instrument;
 
 use crate::address_list::AddressListError;
 use crate::connection_pool::ConnectionPool;
-use crate::transport::TransportError;
 use crate::{
-    transport::{TransportClient, TransportRequest},
+    transport::{TransportClient, TransportError, TransportRequest},
     AddressList, CanRetry, DapiRequestExecutor, ExecutionError, ExecutionResponse, ExecutionResult,
     RequestSettings,
 };

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

@@ -23,18 +23,19 @@ 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.
+    /// It is a 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.
+/// Convert inner type without losing additional context information of the wrapper.
 pub trait InnerInto<T> {
-    /// Convert inner type without loosing additional context information of the wrapper.
+    /// Convert inner type without losing 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
@@ -49,7 +50,7 @@ impl<F, T> InnerInto<ExecutionError<T>> for ExecutionError<F>
 where
     F: Into<T>,
 {
-    /// Convert inner error type without loosing retries and address
+    /// Convert inner error type without losing retries and address
     fn inner_into(self) -> ExecutionError<T> {
         ExecutionError {
             inner: self.inner.into(),
@@ -77,6 +78,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,
@@ -111,7 +113,7 @@ impl<F, T> InnerInto<ExecutionResponse<T>> for ExecutionResponse<F>
 where
     F: Into<T>,
 {
-    /// Convert inner response type without loosing retries and address
+    /// Convert inner response type without losing retries and address
     fn inner_into(self) -> ExecutionResponse<T> {
         ExecutionResponse {
             inner: self.inner.into(),

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

@@ -257,32 +257,83 @@ impl Expectations {
 
 impl<R: Mockable> Mockable for ExecutionResponse<R> {
     fn mock_serialize(&self) -> Option<Vec<u8>> {
-        R::mock_serialize(&self.inner)
+        // We encode data as vec![inner, address, retries] where each od them is serialized to bytes
+        let ser: Vec<Vec<u8>> = vec![
+            self.inner
+                .mock_serialize()
+                .expect("unable to serialize ExecutionResponse inner"),
+            self.address
+                .mock_serialize()
+                .expect("unable to serialize ExecutionResponse address"),
+            (self.retries as u64)
+                .mock_serialize()
+                .expect("unable to serialize ExecutionResponse retries"),
+        ];
+
+        ser.mock_serialize()
     }
 
     fn mock_deserialize(data: &[u8]) -> Option<Self> {
-        // TODO: We need serialize retries and address too
-        R::mock_deserialize(data).map(|inner| ExecutionResponse {
-            inner,
-            retries: 0,
-            address: "http://127.0.0.1:9000"
-                .parse()
-                .expect("failed to parse address"),
+        let deser: Vec<Vec<u8>> =
+            Mockable::mock_deserialize(data).expect("unable to deserialize ExecutionResponse");
+
+        let [inner, address, retries] = &deser[0..] else {
+            // panics intentionally, as this is just for mocking, and we know these types can be mocked
+            // because they were serialized somehow :)
+            panic!(
+                "invalid ExecutionResponse data: expected 3 elements, got {}",
+                deser.len()
+            );
+        };
+
+        Some(Self {
+            inner: Mockable::mock_deserialize(inner)
+                .expect("unable to deserialize ExecutionResponse inner"),
+            address: Mockable::mock_deserialize(address)
+                .expect("unable to deserialize ExecutionResponse address"),
+            retries: Mockable::mock_deserialize(retries)
+                .expect("unable to deserialize ExecutionResponse retries"),
         })
     }
 }
 
 impl<E: Mockable> Mockable for ExecutionError<E> {
     fn mock_serialize(&self) -> Option<Vec<u8>> {
-        E::mock_serialize(&self.inner)
+        // We encode data as vec![inner, address, retries] where each od them is serialized to bytes
+        let ser: Vec<Vec<u8>> = vec![
+            self.inner
+                .mock_serialize()
+                .expect("unable to serialize ExecutionError inner"),
+            self.address
+                .mock_serialize()
+                .expect("unable to serialize ExecutionError address"),
+            self.retries
+                .mock_serialize()
+                .expect("unable to serialize ExecutionError retries"),
+        ];
+
+        ser.mock_serialize()
     }
 
     fn mock_deserialize(data: &[u8]) -> Option<Self> {
-        // TODO: We need serialize retries and address too
-        E::mock_deserialize(data).map(|inner| ExecutionError {
-            inner,
-            retries: 0,
-            address: None,
+        let deser: Vec<Vec<u8>> =
+            Mockable::mock_deserialize(data).expect("unable to deserialize ExecutionError");
+
+        let [inner, address, retries] = &deser[0..] else {
+            // panics intentionally, as this is just for mocking, and we know these types can be mocked because they were
+            // serialized before
+            panic!(
+                "invalid ExecutionError data: expected 3 elements, got {}",
+                deser.len()
+            );
+        };
+        Some(Self {
+            inner: Mockable::mock_deserialize(inner)
+                .expect("unable to deserialize ExecutionError inner"),
+            address: Mockable::mock_deserialize(address)
+                .expect("unable to deserialize ExecutionError address"),
+            retries: Mockable::mock_deserialize(retries)
+                .expect("unable to deserialize ExecutionError retries"),
         })
     }
 }

packages/rs-drive-proof-verifier/Cargo.toml

@@ -11,7 +11,7 @@ default = ["mocks"]
 mocks = [
   "dep:serde",
   "dep:serde_json",
-  "dep:bincode",
+  "bincode/serde",
   "dep:platform-serialization-derive",
   "dep:platform-serialization",
   "dpp/document-serde-conversion",
@@ -20,6 +20,7 @@ mocks = [
 
 [dependencies]
 
+bincode = { version = "2.0.0-rc.3" }
 thiserror = { version = "1.0.63" }
 dapi-grpc = { path = "../dapi-grpc" }
 drive = { path = "../rs-drive", default-features = false, features = [
@@ -31,7 +32,6 @@ dpp = { path = "../rs-dpp", features = [
   "extended-document",
   "core-types-serialization",
 ], default-features = false }
-bincode = { version = "2.0.0-rc.3", features = ["serde"], optional = true }
 platform-serialization-derive = { path = "../rs-platform-serialization-derive", optional = true }
 platform-serialization = { path = "../rs-platform-serialization", optional = true }
 tenderdash-abci = { git = "https://github.com/dashpay/rs-tenderdash-abci", version = "1.2.1", tag = "v1.2.1+1.3.0", features = [

packages/rs-drive-proof-verifier/src/error.rs

@@ -2,6 +2,7 @@ use dpp::ProtocolError;
 
 /// Errors
 #[derive(Debug, thiserror::Error)]
+#[cfg_attr(feature = "mocks", derive(bincode::Encode, bincode::Decode))]
 #[allow(missing_docs)]
 pub enum Error {
     /// Not initialized
@@ -86,6 +87,7 @@ pub enum Error {
 
 /// Errors returned by the context provider
 #[derive(Debug, thiserror::Error)]
+#[cfg_attr(feature = "mocks", derive(bincode::Encode, bincode::Decode))]
 pub enum ContextProviderError {
     /// Generic Context provider error
     #[error("Context provider error: {0}")]

packages/rs-drive-proof-verifier/src/provider.rs

@@ -1,9 +1,9 @@
 use crate::error::ContextProviderError;
 use dpp::prelude::{CoreBlockHeight, DataContract, Identifier};
 use drive::{error::proof::ProofError, query::ContractLookupFn};
+use std::{ops::Deref, sync::Arc};
 #[cfg(feature = "mocks")]
-use hex::ToHex;
-use std::{io::ErrorKind, ops::Deref, sync::Arc};
+use {hex::ToHex, std::io::ErrorKind};
 
 /// Interface between the Sdk and state of the application.
 ///