add first era reader adapters

Author: ghubertpalo

mithril-common/src/era/adapters/bootstrap.rs

@@ -0,0 +1,43 @@
+use async_trait::async_trait;
+
+use crate::entities::Epoch;
+
+use super::super::{EraMarker, EraReaderAdapter, SupportedEra};
+
+/// The goal of the bootstrap adapter is to advertise for the first existing Era
+/// while it does not exist yet on any backend. This adapter is intended to be
+/// removed once Eras are effectively written in a backend.
+pub struct BootstrapAdapter;
+
+#[async_trait]
+impl EraReaderAdapter for BootstrapAdapter {
+    async fn read(&self) -> Result<Vec<EraMarker>, Box<dyn std::error::Error>> {
+        Ok(vec![EraMarker::new(
+            &SupportedEra::Thales.to_string(),
+            Some(Epoch(1)),
+        )])
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::era::SupportedEra;
+
+    use super::*;
+
+    #[tokio::test]
+    async fn bootstrap_adapter() {
+        let adapter = BootstrapAdapter;
+
+        assert_eq!(
+            vec![EraMarker::new(
+                &SupportedEra::dummy().to_string(),
+                Some(Epoch(1))
+            )],
+            adapter
+                .read()
+                .await
+                .expect("bootstrap adapter shall never fail")
+        );
+    }
+}

mithril-common/src/era/adapters/dummy.rs

@@ -0,0 +1,65 @@
+use std::error::Error;
+
+use async_trait::async_trait;
+
+use super::super::{EraMarker, EraReaderAdapter};
+
+/// Dummy adapter is intended to be used in a test environment (end to end test)
+/// to simulate not yet activated Eras.
+#[derive(Default)]
+pub struct DummyAdapter {
+    markers: Vec<EraMarker>,
+}
+
+impl DummyAdapter {
+    /// Tells what markers should be sent back by the adapter.
+    pub fn set_markers(&mut self, markers: Vec<EraMarker>) {
+        self.markers = markers;
+    }
+}
+
+#[async_trait]
+impl EraReaderAdapter for DummyAdapter {
+    async fn read(&self) -> Result<Vec<EraMarker>, Box<dyn Error>> {
+        Ok(self.markers.clone())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::entities::Epoch;
+
+    use super::super::super::SupportedEra;
+    use super::*;
+
+    #[tokio::test]
+    async fn empty_dummy_adapter() {
+        let adapter = DummyAdapter::default();
+
+        assert!(adapter
+            .read()
+            .await
+            .expect("dummy adapter shall not fail reading")
+            .is_empty());
+    }
+
+    #[tokio::test]
+    async fn dummy_adapter_output() {
+        let markers = vec![
+            EraMarker::new("one", Some(Epoch(1))),
+            EraMarker::new(&SupportedEra::dummy().to_string(), None),
+            EraMarker::new(&SupportedEra::dummy().to_string(), Some(Epoch(10))),
+        ];
+
+        let mut adapter = DummyAdapter::default();
+        adapter.set_markers(markers.clone());
+
+        assert_eq!(
+            markers,
+            adapter
+                .read()
+                .await
+                .expect("dummy adapter shall not fail reading")
+        );
+    }
+}

mithril-common/src/era/adapters/mod.rs

@@ -0,0 +1,6 @@
+//! Module dedicated to [EraReaderAdapter] implementations.
+mod bootstrap;
+mod dummy;
+
+pub use bootstrap::BootstrapAdapter;
+pub use dummy::DummyAdapter;

mithril-common/src/era/era_reader.rs

@@ -13,6 +13,15 @@ pub struct EraMarker {
     epoch: Option<Epoch>,
 }
 
+impl EraMarker {
+    /// instanciate a new [EraMarker].
+    pub fn new(name: &str, epoch: Option<Epoch>) -> Self {
+        let name = name.to_string();
+
+        Self { name, epoch }
+    }
+}
+
 /// Adapters are responsible of technically reading the information of
 /// [EraMarker]s from a backend.
 #[async_trait]
@@ -146,38 +155,21 @@ impl EraReader {
 
 #[cfg(test)]
 mod tests {
+    use super::super::adapters::DummyAdapter;
     use super::*;
 
-    #[derive(Default)]
-    struct DummyAdapter {
-        markers: Vec<EraMarker>,
-    }
-
-    impl DummyAdapter {
-        pub fn set_markers(&mut self, markers: Vec<EraMarker>) {
-            self.markers = markers;
-        }
-    }
-
-    #[async_trait]
-    impl EraReaderAdapter for DummyAdapter {
-        async fn read(&self) -> Result<Vec<EraMarker>, Box<dyn StdError>> {
-            Ok(self.markers.clone())
-        }
-    }
-
     fn get_basic_marker_sample() -> Vec<EraMarker> {
         vec![
             EraMarker {
                 name: "one".to_string(),
                 epoch: Some(Epoch(1)),
             },
             EraMarker {
-                name: "thales".to_string(),
+                name: SupportedEra::dummy().to_string(),
                 epoch: None,
             },
             EraMarker {
-                name: "thales".to_string(),
+                name: SupportedEra::dummy().to_string(),
                 epoch: Some(Epoch(10)),
             },
         ]
@@ -196,7 +188,7 @@ mod tests {
             EraEpochToken {
                 current_epoch: Epoch(10),
                 current_era: EraMarker {
-                    name: "thales".to_string(),
+                    name: SupportedEra::dummy().to_string(),
                     epoch: Some(Epoch(10))
                 },
                 next_era: None,
@@ -243,7 +235,7 @@ mod tests {
                     epoch: Some(Epoch(1))
                 },
                 next_era: Some(EraMarker {
-                    name: "thales".to_string(),
+                    name: SupportedEra::dummy().to_string(),
                     epoch: Some(Epoch(10))
                 }),
             },

mithril-common/src/era/mod.rs

@@ -1,5 +1,6 @@
 //! The module used for handling eras
 
+pub mod adapters;
 mod era_checker;
 mod era_reader;
 mod supported_era;

mithril-common/src/era/supported_era.rs

@@ -29,10 +29,24 @@ impl FromStr for SupportedEra {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let s = s.trim().to_lowercase();
 
-        if &s == "thales" {
-            Ok(Self::Thales)
-        } else {
-            Err(UnsupportedEraError(s))
+        let era = match s.as_str() {
+            "thales" => Self::Thales,
+            _ => return Err(UnsupportedEraError(s)),
+        };
+
+        // This is intended to make the compiler to complain when a new variant
+        // is added in order not to forget to add a conversion for the new
+        // variant.
+        match era {
+            Self::Thales => Ok(Self::Thales),
+        }
+    }
+}
+
+impl ToString for SupportedEra {
+    fn to_string(&self) -> String {
+        match self {
+            Self::Thales => "thales".to_owned(),
         }
     }
 }