@dashevo/dapi-grpc 0.25.21 → 1.0.0-beta.1

package/src/mock/serde_mockable.rs

@@ -0,0 +1,105 @@
+//! Serde serialization and deserialization for Mockable objects.
+//!
+//! This module provides a custom serialization and deserialization implementation for Mockable objects.
+//!
+//! /// ## Example
+///
+/// ```rust
+/// struct SomeObject {
+///    field: u32,
+/// }
+///
+/// impl dapi_grpc::mock::Mockable for SomeObject {
+///   fn mock_serialize(&self) -> Option<Vec<u8>> {
+///       Some(self.field.to_be_bytes().to_vec())
+///   }
+///
+///   fn mock_deserialize(bytes: &[u8]) -> Option<Self> {
+///      if bytes.len() != 4 {
+///         return None;
+///      }
+///
+///      Some(SomeObject {   
+///         field: u32::from_be_bytes(bytes.try_into().expect("4 bytes")),
+///      })
+///   }
+/// }
+///
+/// #[derive(serde::Serialize,serde::Deserialize)]
+/// struct TestStruct {
+///     #[serde(with="dapi_grpc::mock::serde_mockable")]
+///     field: SomeObject,
+/// }
+/// ```
+use super::Mockable;
+
+use serde::{
+    de::{self, Visitor},
+    Deserializer, Serializer,
+};
+use serde_bytes::Deserialize;
+use std::fmt;
+use std::marker::PhantomData;
+
+/// Serialize any Mockable object to bytes.
+///
+/// ## Example
+///
+/// `#[serde(with="dapi_grpc::mock::serde_mockable")]`
+pub fn serialize<T: Mockable, S>(data: &T, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    match data.mock_serialize() {
+        Some(bytes) => serializer.serialize_bytes(bytes.as_slice()),
+        None => Err(serde::ser::Error::custom(
+            "Mockable object is not serializable",
+        )),
+    }
+}
+
+struct MockableVisitor<T> {
+    marker: PhantomData<T>,
+}
+
+impl<'de, T> Visitor<'de> for MockableVisitor<T>
+where
+    T: Mockable,
+{
+    type Value = T;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("a byte array")
+    }
+
+    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        T::mock_deserialize(v).ok_or_else(|| E::custom("Failed to deserialize Mockable object"))
+    }
+
+    fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
+    where
+        A: de::SeqAccess<'de>,
+    {
+        let bytes = <Vec<u8>>::deserialize(de::value::SeqAccessDeserializer::new(seq))?;
+        T::mock_deserialize(&bytes).ok_or_else(|| {
+            serde::de::Error::custom("Failed to deserialize Mockable object from seq")
+        })
+    }
+}
+
+/// Deserialize any Mockable object from bytes.
+///
+/// ## Example
+///
+/// `#[serde(with="dapi_grpc::mock::serde_mockable")]`
+pub fn deserialize<'de, T: Mockable, D>(deserializer: D) -> Result<T, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    deserializer.deserialize_bytes(MockableVisitor {
+        marker: PhantomData,
+    })
+}

package/src/mock.rs

@@ -0,0 +1,130 @@
+//! Mocking support for messages.
+//!
+//! Contains [Mockable] trait that should be implemented by any object that can be used in the DAPI.
+//!
+//! Note that this trait is defined even if mocks are not supported, but it should always return `None` on serialization.
+
+#[cfg(feature = "mocks")]
+pub mod serde_mockable;
+
+use tonic::Streaming;
+
+/// Mocking support for messages.
+///
+/// This trait should be implemented by any object that can be used in the DAPI.
+///
+/// We use serde_json to serialize/deserialize messages.
+//  TODO: Move to a different crate where it can be easily shared by dapi-grpc, dash-platform-sdk, and rs-dapi-client.
+pub trait Mockable
+where
+    Self: std::marker::Sized,
+{
+    /// Serialize the message to bytes for mocking purposes.
+    ///
+    /// Returns None if the message is not serializable or mocking is disabled.
+    ///
+    /// # Panics
+    ///
+    /// Panics on any error.
+    fn mock_serialize(&self) -> Option<Vec<u8>> {
+        None
+    }
+    /// 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")]
+#[derive(serde::Serialize, serde::Deserialize)]
+enum SerializableResult {
+    Ok(Vec<u8>),
+    Err(Vec<u8>),
+}
+impl<T, E> Mockable for Result<T, E>
+where
+    T: Mockable,
+    E: Mockable,
+{
+    #[cfg(feature = "mocks")]
+    fn mock_serialize(&self) -> Option<Vec<u8>> {
+        let serializable = match self {
+            Ok(value) => SerializableResult::Ok(value.mock_serialize()?),
+            Err(error) => SerializableResult::Err(error.mock_serialize()?),
+        };
+        serde_json::to_vec(&serializable).ok()
+    }
+
+    #[cfg(feature = "mocks")]
+    fn mock_deserialize(data: &[u8]) -> Option<Self> {
+        if data.is_empty() {
+            return None;
+        }
+        let deser: SerializableResult =
+            serde_json::from_slice(data).expect("unable to deserialize mock data");
+        Some(match deser {
+            SerializableResult::Ok(data) => Ok(T::mock_deserialize(&data)?),
+            SerializableResult::Err(data) => Err(E::mock_deserialize(&data)?),
+        })
+    }
+}
+
+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())
+    }
+
+    #[cfg(feature = "mocks")]
+    fn mock_deserialize(data: &[u8]) -> Option<Self> {
+        T::mock_deserialize(data).map(Some)
+    }
+}
+
+impl Mockable for Vec<u8> {
+    #[cfg(feature = "mocks")]
+    fn mock_serialize(&self) -> Option<Vec<u8>> {
+        serde_json::to_vec(self).ok()
+    }
+
+    #[cfg(feature = "mocks")]
+    fn mock_deserialize(data: &[u8]) -> Option<Self> {
+        serde_json::from_slice(data).ok()
+    }
+}
+#[cfg(feature = "mocks")]
+#[derive(serde::Serialize, serde::Deserialize)]
+struct MockableStatus {
+    code: i32,
+    message: Vec<u8>,
+}
+impl Mockable for crate::tonic::Status {
+    #[cfg(feature = "mocks")]
+    fn mock_serialize(&self) -> Option<Vec<u8>> {
+        let mockable = MockableStatus {
+            code: self.code().into(),
+            message: self.message().as_bytes().to_vec(),
+        };
+
+        Some(serde_json::to_vec(&mockable).expect("unable to serialize tonic::Status"))
+    }
+
+    #[cfg(feature = "mocks")]
+    fn mock_deserialize(data: &[u8]) -> Option<Self> {
+        let MockableStatus { code, message } =
+            serde_json::from_slice(data).expect("unable to deserialize tonic::Status");
+        let message = std::str::from_utf8(&message).expect("invalid utf8 message in tonic::Status");
+        Some(Self::new(code.into(), message))
+    }
+}
+
+/// Mocking of gRPC streaming responses is not supported.
+///
+/// This will return `None` on serialization,
+/// effectively disabling mocking of streaming responses.
+impl<T: Mockable> Mockable for Streaming<T> {}

package/test/unit/clients/core/v0/nodejs/CorePromiseClient.spec.js

@@ -11,7 +11,8 @@ describe('CorePromiseClient', () => {
 
     corePromiseClient = new CorePromiseClient('https://localhost/');
     corePromiseClient.client = {
-      getStatus: this.sinon.stub().resolves(response),
+      getBlockchainStatus: this.sinon.stub().resolves(response),
+      getMasternodeStatus: this.sinon.stub().resolves(response),
       getBlock: this.sinon.stub().resolves(response),
       broadcastTransaction: this.sinon.stub().resolves(response),
       getTransaction: this.sinon.stub().resolves(response),
@@ -20,17 +21,37 @@ describe('CorePromiseClient', () => {
     };
   });
 
-  describe('#getStatus', () => {
-    it('should return status', async () => {
-      const result = await corePromiseClient.getStatus(request);
+  describe('#getBlockchainStatus', () => {
+    it('should return core chain status', async () => {
+      const result = await corePromiseClient.getBlockchainStatus(request);
+
+      expect(result).to.equal(response);
+      expect(corePromiseClient.client.getBlockchainStatus).to.be.calledOnceWith(request);
+    });
+
+    it('should throw an error when metadata is not an object', async () => {
+      try {
+        corePromiseClient.getBlockchainStatus({}, 'metadata');
+
+        expect.fail('Error was not thrown');
+      } catch (e) {
+        expect(e.message).to.equal('metadata must be an object');
+      }
+    });
+  });
+
+  describe('#getMasternodeStatus', () => {
+    it('should return masternode status', async () => {
+      const result = await corePromiseClient.getMasternodeStatus(request);
 
       expect(result).to.equal(response);
-      expect(corePromiseClient.client.getStatus).to.be.calledOnceWith(request);
+      expect(corePromiseClient.client.getMasternodeStatus)
+        .to.be.calledOnceWith(request);
     });
 
     it('should throw an error when metadata is not an object', async () => {
       try {
-        corePromiseClient.getStatus({}, 'metadata');
+        corePromiseClient.getMasternodeStatus({}, 'metadata');
 
         expect.fail('Error was not thrown');
       } catch (e) {

package/test/unit/clients/platform/v0/nodejs/PlatformPromiseClient.spec.js

@@ -13,11 +13,15 @@ describe('PlatformPromiseClient', () => {
     platformPromiseClient.client = {
       broadcastStateTransition: this.sinon.stub().resolves(response),
       getIdentity: this.sinon.stub().resolves(response),
+      getIdentitiesContractKeys: this.sinon.stub().resolves(response),
       getDataContract: this.sinon.stub().resolves(response),
       getDocuments: this.sinon.stub().resolves(response),
       getEpochsInfo: this.sinon.stub().resolves(response),
       getProtocolVersionUpgradeVoteStatus: this.sinon.stub().resolves(response),
       getProtocolVersionUpgradeState: this.sinon.stub().resolves(response),
+      getIdentityContractNonce: this.sinon.stub().resolves(response),
+      getIdentityNonce: this.sinon.stub().resolves(response),
+      getIdentityKeys: this.sinon.stub().resolves(response),
     };
   });
 
@@ -60,6 +64,26 @@ describe('PlatformPromiseClient', () => {
     });
   });
 
+  describe('#getIdentitiesContractKeys', () => {
+    it('should get identities', async () => {
+      const result = await platformPromiseClient.getIdentitiesContractKeys(request);
+
+      expect(result).to.equal(response);
+      expect(platformPromiseClient.client.getIdentitiesContractKeys)
+        .to.be.calledOnceWith(request);
+    });
+
+    it('should throw an error when metadata is not an object', async () => {
+      try {
+        platformPromiseClient.getIdentitiesContractKeys({}, 'metadata');
+
+        expect.fail('Error was not thrown');
+      } catch (e) {
+        expect(e.message).to.equal('metadata must be an object');
+      }
+    });
+  });
+
   describe('#getDataContract', () => {
     it('should get data contract', async () => {
       const result = await platformPromiseClient.getDataContract(request);
@@ -98,7 +122,7 @@ describe('PlatformPromiseClient', () => {
   });
 
   describe('#getProtocolVersionUpgradeVoteStatus', () => {
-    it('should get version upgrade vote status', async () => {
+    it('should get version upgrade votes status', async () => {
       const result = await platformPromiseClient.getProtocolVersionUpgradeVoteStatus(request);
 
       expect(result).to.equal(response);
@@ -116,4 +140,34 @@ describe('PlatformPromiseClient', () => {
         .to.be.calledOnceWith(request);
     });
   });
+
+  describe('#getIdentityContractNonce', () => {
+    it('should get identity contract nonce', async () => {
+      const result = await platformPromiseClient.getIdentityContractNonce(request);
+
+      expect(result).to.equal(response);
+      expect(platformPromiseClient.client.getIdentityContractNonce)
+        .to.be.calledOnceWith(request);
+    });
+  });
+
+  describe('#getIdentityNonce', () => {
+    it('should get identity nonce', async () => {
+      const result = await platformPromiseClient.getIdentityNonce(request);
+
+      expect(result).to.equal(response);
+      expect(platformPromiseClient.client.getIdentityNonce)
+        .to.be.calledOnceWith(request);
+    });
+  });
+
+  describe('#getIdentityKeys', () => {
+    it('should get identity keys', async () => {
+      const result = await platformPromiseClient.getIdentityKeys(request);
+
+      expect(result).to.equal(response);
+      expect(platformPromiseClient.client.getIdentityKeys)
+        .to.be.calledOnceWith(request);
+    });
+  });
 });

package/test/unit/getCoreDefinition.spec.js

@@ -14,8 +14,11 @@ describe('getCoreDefinition', () => {
       expect(coreDefinition.service).to.have.property('getTransaction');
       expect(coreDefinition.service.getTransaction.path).to.equal('/org.dash.platform.dapi.v0.Core/getTransaction');
 
-      expect(coreDefinition.service).to.have.property('getStatus');
-      expect(coreDefinition.service.getStatus.path).to.equal('/org.dash.platform.dapi.v0.Core/getStatus');
+      expect(coreDefinition.service).to.have.property('getBlockchainStatus');
+      expect(coreDefinition.service.getBlockchainStatus.path).to.equal('/org.dash.platform.dapi.v0.Core/getBlockchainStatus');
+
+      expect(coreDefinition.service).to.have.property('getMasternodeStatus');
+      expect(coreDefinition.service.getMasternodeStatus.path).to.equal('/org.dash.platform.dapi.v0.Core/getMasternodeStatus');
 
       expect(coreDefinition.service).to.have.property('getBlock');
       expect(coreDefinition.service.getBlock.path).to.equal('/org.dash.platform.dapi.v0.Core/getBlock');