test(client-lib): simplify cardano stake distribution tests

- unify error handlings tests by testing the inner function that handle
  them directly instead of copying those tests for each
- use dummy directly instead of modifying them since it does not bring
  much value here

Author: Alenar

mithril-client/src/cardano_stake_distribution_client.rs

@@ -145,7 +145,7 @@ mod tests {
     use mockall::predicate::eq;
 
     use crate::aggregator_client::MockAggregatorClient;
-    use crate::common::StakeDistribution;
+    use crate::common::test::Dummy;
 
     use super::*;
 
@@ -171,24 +171,7 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn list_cardano_stake_distributions_returns_messages() {
-        let message = fake_messages();
-        let mut http_client = MockAggregatorClient::new();
-        http_client
-            .expect_get_content()
-            .with(eq(AggregatorRequest::ListCardanoStakeDistributions))
-            .return_once(move |_| Ok(serde_json::to_string(&message).unwrap()));
-        let client = CardanoStakeDistributionClient::new(Arc::new(http_client));
-
-        let messages = client.list().await.unwrap();
-
-        assert_eq!(2, messages.len());
-        assert_eq!("hash-123".to_string(), messages[0].hash);
-        assert_eq!("hash-456".to_string(), messages[1].hash);
-    }
-
-    #[tokio::test]
-    async fn list_cardano_stake_distributions_returns_error_when_invalid_json_structure_in_response()
+    async fn fetching_cardano_stake_distribution_from_aggregator_client_returns_error_when_invalid_json_structure_in_response()
      {
         let mut http_client = MockAggregatorClient::new();
         http_client
@@ -197,61 +180,13 @@ mod tests {
         let client = CardanoStakeDistributionClient::new(Arc::new(http_client));
 
         client
-            .list()
-            .await
-            .expect_err("List Cardano stake distributions should return an error");
-    }
-
-    #[tokio::test]
-    async fn get_cardano_stake_distribution_returns_message() {
-        let expected_stake_distribution = StakeDistribution::from([("pool123".to_string(), 123)]);
-        let message = CardanoStakeDistribution {
-            epoch: Epoch(3),
-            hash: "hash-123".to_string(),
-            certificate_hash: "certificate-hash-123".to_string(),
-            stake_distribution: expected_stake_distribution.clone(),
-            created_at: DateTime::<Utc>::default(),
-        };
-        let mut http_client = MockAggregatorClient::new();
-        http_client
-            .expect_get_content()
-            .with(eq(AggregatorRequest::GetCardanoStakeDistribution {
-                hash: "hash-123".to_string(),
-            }))
-            .return_once(move |_| Ok(serde_json::to_string(&message).unwrap()));
-        let client = CardanoStakeDistributionClient::new(Arc::new(http_client));
-
-        let cardano_stake_distribution = client
-            .get("hash-123")
-            .await
-            .unwrap()
-            .expect("This test returns a Cardano stake distribution");
-
-        assert_eq!("hash-123".to_string(), cardano_stake_distribution.hash);
-        assert_eq!(Epoch(3), cardano_stake_distribution.epoch);
-        assert_eq!(
-            expected_stake_distribution,
-            cardano_stake_distribution.stake_distribution
-        );
-    }
-
-    #[tokio::test]
-    async fn get_cardano_stake_distribution_returns_error_when_invalid_json_structure_in_response()
-    {
-        let mut http_client = MockAggregatorClient::new();
-        http_client
-            .expect_get_content()
-            .return_once(move |_| Ok("invalid json structure".to_string()));
-        let client = CardanoStakeDistributionClient::new(Arc::new(http_client));
-
-        client
-            .get("hash-123")
+            .fetch_with_aggregator_request(AggregatorRequest::ListCardanoStakeDistributions)
             .await
             .expect_err("Get Cardano stake distribution should return an error");
     }
 
     #[tokio::test]
-    async fn get_cardano_stake_distribution_returns_none_when_not_found_or_remote_server_logical_error()
+    async fn fetching_cardano_stake_distribution_from_aggregator_client_returns_none_when_not_found_or_remote_server_logical_error()
      {
         let mut http_client = MockAggregatorClient::new();
         http_client.expect_get_content().return_once(move |_| {
@@ -261,100 +196,88 @@ mod tests {
         });
         let client = CardanoStakeDistributionClient::new(Arc::new(http_client));
 
-        let result = client.get("hash-123").await.unwrap();
+        let result = client
+            .fetch_with_aggregator_request(AggregatorRequest::ListCardanoStakeDistributions)
+            .await
+            .unwrap();
 
         assert!(result.is_none());
     }
 
     #[tokio::test]
-    async fn get_cardano_stake_distribution_returns_error() {
+    async fn fetching_cardano_stake_distribution_from_aggregator_client_returns_error() {
         let mut http_client = MockAggregatorClient::new();
         http_client
             .expect_get_content()
             .return_once(move |_| Err(AggregatorClientError::SubsystemError(anyhow!("error"))));
         let client = CardanoStakeDistributionClient::new(Arc::new(http_client));
 
         client
-            .get("hash-123")
+            .fetch_with_aggregator_request(AggregatorRequest::ListCardanoStakeDistributions)
             .await
             .expect_err("Get Cardano stake distribution should return an error");
     }
 
     #[tokio::test]
-    async fn get_cardano_stake_distribution_by_epoch_returns_message() {
-        let expected_stake_distribution = StakeDistribution::from([("pool123".to_string(), 123)]);
-        let message = CardanoStakeDistribution {
-            epoch: Epoch(3),
-            hash: "hash-123".to_string(),
-            certificate_hash: "certificate-hash-123".to_string(),
-            stake_distribution: expected_stake_distribution.clone(),
-            created_at: DateTime::<Utc>::default(),
-        };
+    async fn list_cardano_stake_distributions_returns_messages() {
+        let message = fake_messages();
         let mut http_client = MockAggregatorClient::new();
         http_client
             .expect_get_content()
-            .with(eq(AggregatorRequest::GetCardanoStakeDistributionByEpoch {
-                epoch: Epoch(3),
-            }))
+            .with(eq(AggregatorRequest::ListCardanoStakeDistributions))
             .return_once(move |_| Ok(serde_json::to_string(&message).unwrap()));
         let client = CardanoStakeDistributionClient::new(Arc::new(http_client));
 
-        let cardano_stake_distribution = client
-            .get_by_epoch(Epoch(3))
-            .await
-            .unwrap()
-            .expect("This test returns a Cardano stake distribution");
+        let messages = client.list().await.unwrap();
 
-        assert_eq!("hash-123".to_string(), cardano_stake_distribution.hash);
-        assert_eq!(Epoch(3), cardano_stake_distribution.epoch);
-        assert_eq!(
-            expected_stake_distribution,
-            cardano_stake_distribution.stake_distribution
-        );
+        assert_eq!(2, messages.len());
+        assert_eq!("hash-123".to_string(), messages[0].hash);
+        assert_eq!("hash-456".to_string(), messages[1].hash);
     }
 
     #[tokio::test]
-    async fn get_cardano_stake_distribution_by_epoch_returns_error_when_invalid_json_structure_in_response()
-     {
+    async fn get_cardano_stake_distribution_returns_message() {
+        let expected_message = CardanoStakeDistribution::dummy();
         let mut http_client = MockAggregatorClient::new();
         http_client
             .expect_get_content()
-            .return_once(move |_| Ok("invalid json structure".to_string()));
+            .with(eq(AggregatorRequest::GetCardanoStakeDistribution {
+                hash: expected_message.hash.clone(),
+            }))
+            .return_once(move |_| {
+                Ok(serde_json::to_string(&CardanoStakeDistribution::dummy()).unwrap())
+            });
         let client = CardanoStakeDistributionClient::new(Arc::new(http_client));
 
-        client
-            .get_by_epoch(Epoch(3))
+        let cardano_stake_distribution = client
+            .get(&expected_message.hash)
             .await
-            .expect_err("Get Cardano stake distribution by epoch should return an error");
-    }
-
-    #[tokio::test]
-    async fn get_cardano_stake_distribution_by_epoch_returns_none_when_not_found_or_remote_server_logical_error()
-     {
-        let mut http_client = MockAggregatorClient::new();
-        http_client.expect_get_content().return_once(move |_| {
-            Err(AggregatorClientError::RemoteServerLogical(anyhow!(
-                "not found"
-            )))
-        });
-        let client = CardanoStakeDistributionClient::new(Arc::new(http_client));
-
-        let result = client.get_by_epoch(Epoch(3)).await.unwrap();
+            .unwrap()
+            .expect("This test returns a Cardano stake distribution");
 
-        assert!(result.is_none());
+        assert_eq!(expected_message, cardano_stake_distribution);
     }
 
     #[tokio::test]
-    async fn get_cardano_stake_distribution_by_epoch_returns_error() {
+    async fn get_cardano_stake_distribution_by_epoch_returns_message() {
+        let expected_message = CardanoStakeDistribution::dummy();
         let mut http_client = MockAggregatorClient::new();
         http_client
             .expect_get_content()
-            .return_once(move |_| Err(AggregatorClientError::SubsystemError(anyhow!("error"))));
+            .with(eq(AggregatorRequest::GetCardanoStakeDistributionByEpoch {
+                epoch: expected_message.epoch,
+            }))
+            .return_once(move |_| {
+                Ok(serde_json::to_string(&CardanoStakeDistribution::dummy()).unwrap())
+            });
         let client = CardanoStakeDistributionClient::new(Arc::new(http_client));
 
-        client
-            .get_by_epoch(Epoch(3))
+        let cardano_stake_distribution = client
+            .get_by_epoch(expected_message.epoch)
             .await
-            .expect_err("Get Cardano stake distribution by epoch should return an error");
+            .unwrap()
+            .expect("This test returns a Cardano stake distribution");
+
+        assert_eq!(expected_message, cardano_stake_distribution);
     }
 }