Update Client implementation #147

jpraynaud · jpraynaud · commit 05a151b20a14 · 2022-05-03T22:28:56.000+02:00
* Add new Verifier dependency
* Add missing tests for restore snapshot
* Cleaned client code for more readability
diff --git a/mithril-network/mithril-client/src/client.rs b/mithril-network/mithril-client/src/client.rs
@@ -1,67 +1,76 @@
 use log::debug;
+use mithril_aggregator::fake_data;
+use std::str;
 
 use crate::aggregator::AggregatorHandler;
 use crate::entities::*;
 use crate::errors;
+use crate::verifier::Verifier;
+
+/// AggregatorHandlerWrapper wraps an AggregatorHandler
+pub type AggregatorHandlerWrapper = Box<dyn AggregatorHandler>;
+
+/// VerifierWrapper wraps a Verifier
+pub type VerifierWrapper = Box<dyn Verifier>;
 
 /// Mithril client wrapper
-pub struct Client<R>
-where
-    R: AggregatorHandler,
-{
+pub struct Client {
     pub network: String,
-    pub aggregator_handler: Option<Box<R>>,
+    pub aggregator_handler: Option<AggregatorHandlerWrapper>,
+    pub verifier: Option<VerifierWrapper>,
 }
 
-impl<R> Client<R>
-where
-    R: AggregatorHandler,
-{
+impl Client {
     /// Client factory
     pub fn new(network: String) -> Self {
         Self {
             network,
             aggregator_handler: None,
+            verifier: None,
         }
     }
 
     /// With AggregatorHandler
-    pub fn with_aggregator_handler(&mut self, aggregator_handler: R) -> &mut Self {
-        self.aggregator_handler = Some(Box::new(aggregator_handler));
+    pub fn with_aggregator_handler(
+        &mut self,
+        aggregator_handler: AggregatorHandlerWrapper,
+    ) -> &mut Self {
+        self.aggregator_handler = Some(aggregator_handler);
+        self
+    }
+
+    /// With Verifier
+    pub fn with_verifier(&mut self, verifier: VerifierWrapper) -> &mut Self {
+        self.verifier = Some(verifier);
         self
     }
-}
 
-impl<R> Client<R>
-where
-    R: AggregatorHandler,
-{
     /// List snapshots
     pub async fn list_snapshots(&self) -> Result<Vec<SnapshotListItem>, String> {
         debug!("List snapshots");
-        match &self.aggregator_handler {
-            Some(aggregator_handler) => match aggregator_handler.list_snapshots().await {
-                Ok(snapshots) => Ok(snapshots
-                    .iter()
-                    .map(|snapshot| convert_to_list_item(snapshot, self.network.clone()))
-                    .collect::<Vec<SnapshotListItem>>()),
-                Err(err) => Err(err),
-            },
-            None => Err(errors::MISSING_AGGREGATOR_HANDLER.to_string()),
-        }
+        let aggregator_handler = &self
+            .aggregator_handler
+            .as_ref()
+            .ok_or_else(|| errors::MISSING_AGGREGATOR_HANDLER.to_string())?;
+        Ok(aggregator_handler
+            .list_snapshots()
+            .await?
+            .iter()
+            .map(|snapshot| convert_to_list_item(snapshot, self.network.clone()))
+            .collect::<Vec<SnapshotListItem>>())
     }
 
     /// Show a snapshot
     pub async fn show_snapshot(&self, digest: &str) -> Result<Vec<SnapshotFieldItem>, String> {
         debug!("Show snapshot {}", digest);
-        match &self.aggregator_handler {
-            Some(aggregator_handler) => match aggregator_handler.get_snapshot_details(digest).await
-            {
-                Ok(snapshot) => Ok(convert_to_field_items(&snapshot, self.network.clone())),
-                Err(err) => Err(err),
-            },
-            None => Err(errors::MISSING_AGGREGATOR_HANDLER.to_string()),
-        }
+        let aggregator_handler = &self
+            .aggregator_handler
+            .as_ref()
+            .ok_or_else(|| errors::MISSING_AGGREGATOR_HANDLER.to_string())?;
+        Ok(convert_to_field_items(
+            &aggregator_handler.get_snapshot_details(digest).await?,
+            self.network.clone(),
+        ))
     }
 
     /// Download a snapshot by digest
@@ -71,36 +80,46 @@ where
         location_index: isize,
     ) -> Result<(String, String), String> {
         debug!("Download snapshot {}", digest);
-        match &self.aggregator_handler {
-            Some(aggregator_handler) => match aggregator_handler.get_snapshot_details(digest).await
-            {
-                Ok(snapshot) => {
-                    let from = snapshot
-                        .locations
-                        .get((location_index - 1) as usize)
-                        .unwrap()
-                        .to_owned();
-                    match aggregator_handler.download_snapshot(digest, &from).await {
-                        Ok(to) => Ok((from, to)),
-                        Err(err) => Err(err),
-                    }
-                }
-                Err(err) => Err(err),
-            },
-            None => Err(errors::MISSING_AGGREGATOR_HANDLER.to_string()),
+        let aggregator_handler = &self
+            .aggregator_handler
+            .as_ref()
+            .ok_or_else(|| errors::MISSING_AGGREGATOR_HANDLER.to_string())?;
+        let snapshot = aggregator_handler.get_snapshot_details(digest).await?;
+        let from = snapshot
+            .locations
+            .get((location_index - 1) as usize)
+            .unwrap()
+            .to_owned();
+        match aggregator_handler.download_snapshot(digest, &from).await {
+            Ok(to) => Ok((from, to)),
+            Err(err) => Err(err),
         }
     }
 
     /// Restore a snapshot by hash
     pub async fn restore_snapshot(&self, digest: &str) -> Result<String, String> {
         debug!("Restore snapshot {}", digest);
-        match &self.aggregator_handler {
-            Some(aggregator_handler) => match aggregator_handler.unpack_snapshot(digest).await {
-                Ok(to) => Ok(to),
-                Err(err) => Err(err),
-            },
-            None => Err(errors::MISSING_AGGREGATOR_HANDLER.to_string()),
-        }
+        let aggregator_handler = &self
+            .aggregator_handler
+            .as_ref()
+            .ok_or_else(|| errors::MISSING_AGGREGATOR_HANDLER.to_string())?;
+        let verifier = &self
+            .verifier
+            .as_ref()
+            .ok_or_else(|| errors::MISSING_VERIFIER.to_string())?;
+        let fake_digest = fake_data::digest();
+        debug!("Fake digest {:?}", fake_digest);
+        let certificate_hash = str::from_utf8(&fake_digest).unwrap();
+        let certificate_details = aggregator_handler
+            .get_certificate_details(certificate_hash)
+            .await?;
+        verifier.verify_multi_signature(
+            &digest.as_bytes().to_vec(),
+            certificate_details.multisignature.as_ref(),
+            &certificate_details.participants,
+            &certificate_details.protocol_parameters,
+        )?;
+        aggregator_handler.unpack_snapshot(digest).await
     }
 }
 
@@ -143,6 +162,7 @@ mod tests {
     use super::*;
 
     use crate::aggregator::MockAggregatorHandler;
+    use crate::verifier::MockVerifier;
     use mithril_aggregator::fake_data;
 
     #[tokio::test]
@@ -155,7 +175,7 @@ mod tests {
             .return_const(Ok(fake_snapshots.clone()))
             .once();
         let mut client = Client::new(network.clone());
-        client.with_aggregator_handler(mock_aggregator_handler);
+        client.with_aggregator_handler(Box::new(mock_aggregator_handler));
         let snapshot_list_items = client.list_snapshots().await;
         snapshot_list_items.as_ref().expect("unexpected error");
         let snapshot_list_items_expected = fake_snapshots
@@ -173,7 +193,7 @@ mod tests {
             .return_const(Err("error occurred".to_string()))
             .once();
         let mut client = Client::new("testnet".to_string());
-        client.with_aggregator_handler(mock_aggregator_handler);
+        client.with_aggregator_handler(Box::new(mock_aggregator_handler));
         let snapshot_list_items = client.list_snapshots().await;
         assert!(
             snapshot_list_items.is_err(),
@@ -191,7 +211,7 @@ mod tests {
             .return_const(Ok(fake_snapshot.clone()))
             .once();
         let mut client = Client::new("testnet".to_string());
-        client.with_aggregator_handler(mock_aggregator_handler);
+        client.with_aggregator_handler(Box::new(mock_aggregator_handler));
         let snapshot_item = client.show_snapshot(digest).await;
         snapshot_item.as_ref().expect("unexpected error");
         let snapshot_item_expected = convert_to_field_items(&fake_snapshot, "testnet".to_string());
@@ -207,8 +227,102 @@ mod tests {
             .return_const(Err("error occurred".to_string()))
             .once();
         let mut client = Client::new("testnet".to_string());
-        client.with_aggregator_handler(mock_aggregator_handler);
+        client.with_aggregator_handler(Box::new(mock_aggregator_handler));
         let snapshot_item = client.show_snapshot(digest).await;
         assert!(snapshot_item.is_err(), "an error should have occurred");
     }
+
+    #[tokio::test]
+    async fn test_restore_snapshot_ok() {
+        let certificate_hash = "certhash123";
+        let fake_certificate = fake_data::certificate(certificate_hash.to_string());
+        let mut mock_aggregator_handler = MockAggregatorHandler::new();
+        let mut mock_verifier = MockVerifier::new();
+        mock_aggregator_handler
+            .expect_get_certificate_details()
+            .return_const(Ok(fake_certificate.clone()))
+            .once();
+        mock_aggregator_handler
+            .expect_unpack_snapshot()
+            .return_const(Ok("".to_string()))
+            .once();
+        mock_verifier
+            .expect_verify_multi_signature()
+            .return_const(Ok(()))
+            .once();
+        let mut client = Client::new("testnet".to_string());
+        client
+            .with_aggregator_handler(Box::new(mock_aggregator_handler))
+            .with_verifier(Box::new(mock_verifier));
+        let restore = client.restore_snapshot(certificate_hash).await;
+        restore.expect("unexpected error");
+    }
+
+    #[tokio::test]
+    async fn test_restore_snapshot_ko_get_certificate_details() {
+        let certificate_hash = "certhash123";
+        let mut mock_aggregator_handler = MockAggregatorHandler::new();
+        let mut mock_verifier = MockVerifier::new();
+        mock_aggregator_handler
+            .expect_get_certificate_details()
+            .return_const(Err("an error".to_string()))
+            .once();
+        mock_aggregator_handler.expect_unpack_snapshot().never();
+        mock_verifier.expect_verify_multi_signature().never();
+        let mut client = Client::new("testnet".to_string());
+        client
+            .with_aggregator_handler(Box::new(mock_aggregator_handler))
+            .with_verifier(Box::new(mock_verifier));
+        let restore = client.restore_snapshot(certificate_hash).await;
+        assert!(restore.is_err(), "an error should have occurred");
+    }
+
+    #[tokio::test]
+    async fn test_restore_snapshot_ko_verify_multi_signature() {
+        let certificate_hash = "certhash123";
+        let fake_certificate = fake_data::certificate(certificate_hash.to_string());
+        let mut mock_aggregator_handler = MockAggregatorHandler::new();
+        let mut mock_verifier = MockVerifier::new();
+        mock_aggregator_handler
+            .expect_get_certificate_details()
+            .return_const(Ok(fake_certificate.clone()))
+            .once();
+        mock_aggregator_handler.expect_unpack_snapshot().never();
+        mock_verifier
+            .expect_verify_multi_signature()
+            .return_const(Err("an error".to_string()))
+            .once();
+        let mut client = Client::new("testnet".to_string());
+        client
+            .with_aggregator_handler(Box::new(mock_aggregator_handler))
+            .with_verifier(Box::new(mock_verifier));
+        let restore = client.restore_snapshot(certificate_hash).await;
+        assert!(restore.is_err(), "an error should have occurred");
+    }
+
+    #[tokio::test]
+    async fn test_restore_unpack_snapshot() {
+        let certificate_hash = "certhash123";
+        let fake_certificate = fake_data::certificate(certificate_hash.to_string());
+        let mut mock_aggregator_handler = MockAggregatorHandler::new();
+        let mut mock_verifier = MockVerifier::new();
+        mock_aggregator_handler
+            .expect_get_certificate_details()
+            .return_const(Ok(fake_certificate.clone()))
+            .once();
+        mock_aggregator_handler
+            .expect_unpack_snapshot()
+            .return_const(Err("an error".to_string()))
+            .once();
+        mock_verifier
+            .expect_verify_multi_signature()
+            .return_const(Ok(()))
+            .once();
+        let mut client = Client::new("testnet".to_string());
+        client
+            .with_aggregator_handler(Box::new(mock_aggregator_handler))
+            .with_verifier(Box::new(mock_verifier));
+        let restore = client.restore_snapshot(certificate_hash).await;
+        assert!(restore.is_err(), "an error should have occurred");
+    }
 }
diff --git a/mithril-network/mithril-client/src/errors.rs b/mithril-network/mithril-client/src/errors.rs
@@ -1 +1,3 @@
 pub const MISSING_AGGREGATOR_HANDLER: &str = "missing aggregator handler";
+
+pub const MISSING_VERIFIER: &str = "missing verifier";
diff --git a/mithril-network/mithril-client/src/main.rs b/mithril-network/mithril-client/src/main.rs
@@ -5,6 +5,7 @@ mod aggregator_fake;
 mod client;
 mod entities;
 mod errors;
+mod verifier;
 
 use clap::{Parser, Subcommand};
 use clap_verbosity_flag::{InfoLevel, Verbosity};
@@ -15,6 +16,7 @@ use std::env;
 use crate::aggregator::*;
 use crate::client::Client;
 use crate::entities::Config;
+use crate::verifier::*;
 
 /// CLI args
 #[derive(Parser)]
@@ -94,12 +96,17 @@ async fn main() {
     debug!("{:?}", config);
 
     // Init dependencies
-    let aggregator_handler =
-        AggregatorHTTPClient::new(config.network.clone(), config.aggregator_endpoint.clone());
+    let aggregator_handler = Box::new(AggregatorHTTPClient::new(
+        config.network.clone(),
+        config.aggregator_endpoint.clone(),
+    ));
+    let verifier = Box::new(VerifierImpl::new());
 
     // Init client
     let mut client = Client::new(config.network.clone());
-    client.with_aggregator_handler(aggregator_handler);
+    client
+        .with_aggregator_handler(aggregator_handler)
+        .with_verifier(verifier);
 
     // Execute commands
     match &args.command {

Original file line number	Diff line number	Diff line change
`@@ -1 +1,3 @@`
`1`	`1`	`pub const MISSING_AGGREGATOR_HANDLER: &str = "missing aggregator handler";`
	`2`	`+`
	`3`	`+pub const MISSING_VERIFIER: &str = "missing verifier";`