Make test backend multithreading capable

Signed-off-by: Matthias Beyer <mail@beyermatthias.de>

3 files changed, 31 insertions, 22 deletions

diff --git a/src/async_dag.rs b/src/async_dag.rs
index cc0a196..7e31110 100644
--- a/src/async_dag.rs
+++ b/src/async_dag.rs
@@ -196,7 +196,7 @@ mod tests {
             data: 43,
         };
 
-        let b = test::Backend(vec![
+        let b = test::Backend::new(vec![
             {
                 Some(test::Node {
                     id: test::Id(0),
@@ -255,7 +255,7 @@ mod tests {
             data: 43,
         };
 
-        let b = test::Backend(vec![
+        let b = test::Backend::new(vec![
             {
                 Some(test::Node {
                     id: test::Id(0),
@@ -286,7 +286,7 @@ mod tests {
             parents: vec![],
             data: 42,
         };
-        let b = test::Backend(vec![Some(head.clone())]);
+        let b = test::Backend::new(vec![Some(head.clone())]);
 
         let dag = tokio_test::block_on(AsyncDag::new(b, head));
         assert!(dag.is_ok());
@@ -298,22 +298,22 @@ mod tests {
             data: 43,
         };
 
-        assert_eq!(dag.backend.0.len(), 1);
+        assert_eq!(dag.backend.0.read().unwrap().len(), 1);
         assert_eq!(dag.head, test::Id(0));
 
         let id = tokio_test::block_on(dag.update_head(new_head));
         assert!(id.is_ok());
         let id = id.unwrap();
 
-        assert_eq!(dag.backend.0.len(), 2);
+        assert_eq!(dag.backend.0.read().unwrap().len(), 2);
         assert_eq!(dag.head, test::Id(1));
 
-        assert_eq!(dag.backend.0[0].as_ref().unwrap().id, test::Id(0));
-        assert!(dag.backend.0[0].as_ref().unwrap().parents.is_empty());
+        assert_eq!(dag.backend.0.read().unwrap()[0].as_ref().unwrap().id, test::Id(0));
+        assert!(dag.backend.0.read().unwrap()[0].as_ref().unwrap().parents.is_empty());
 
-        assert_eq!(dag.backend.0[1].as_ref().unwrap().id, test::Id(1));
-        assert_eq!(dag.backend.0[1].as_ref().unwrap().parents.len(), 1);
-        assert_eq!(dag.backend.0[1].as_ref().unwrap().parents[0], test::Id(0));
+        assert_eq!(dag.backend.0.read().unwrap()[1].as_ref().unwrap().id, test::Id(1));
+        assert_eq!(dag.backend.0.read().unwrap()[1].as_ref().unwrap().parents.len(), 1);
+        assert_eq!(dag.backend.0.read().unwrap()[1].as_ref().unwrap().parents[0], test::Id(0));
     }
 
     #[test]
@@ -324,7 +324,7 @@ mod tests {
                 parents: vec![],
                 data: 42,
             };
-            let b = test::Backend(vec![Some(head.clone())]);
+            let b = test::Backend::new(vec![Some(head.clone())]);
             let dag = tokio_test::block_on(AsyncDag::new(b, head));
             assert!(dag.is_ok());
             dag.unwrap()
@@ -333,7 +333,7 @@ mod tests {
         let branched = dag.branch();
 
         {
-            assert_eq!(dag.backend.0.len(), 1);
+            assert_eq!(dag.backend.0.read().unwrap().len(), 1);
             assert_eq!(dag.head, test::Id(0));
             let new_head = test::Node {
                 id: test::Id(1),
@@ -345,11 +345,11 @@ mod tests {
             assert!(id.is_ok());
             let id = id.unwrap();
 
-            assert_eq!(dag.backend.0.len(), 2);
+            assert_eq!(dag.backend.0.read().unwrap().len(), 2);
             assert_eq!(dag.head, test::Id(1));
         }
 
-        assert_eq!(branched.backend.0.len(), 1);
+        assert_eq!(branched.backend.0.read().unwrap().len(), 1);
         assert_eq!(branched.head, test::Id(0));
     }
 
diff --git a/src/dag_backend.rs b/src/dag_backend.rs
index 8a74c7b..a91a8ec 100644
--- a/src/dag_backend.rs
+++ b/src/dag_backend.rs
@@ -33,7 +33,7 @@ mod tests {
 
     #[test]
     fn test_backend_get() {
-        let b = test::Backend(vec![Some(test::Node {
+        let b = test::Backend::new(vec![Some(test::Node {
             id: test::Id(0),
             parents: vec![],
             data: 42,
@@ -53,7 +53,7 @@ mod tests {
 
     #[test]
     fn test_backend_put() {
-        let mut b = test::Backend(vec![Some(test::Node {
+        let mut b = test::Backend::new(vec![Some(test::Node {
             id: test::Id(0),
             parents: vec![],
             data: 42,
diff --git a/src/test_impl.rs b/src/test_impl.rs
index ae7ce0c..cd6dd26 100644
--- a/src/test_impl.rs
+++ b/src/test_impl.rs
@@ -4,6 +4,9 @@
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 //
 
+use std::sync::Arc;
+use std::sync::RwLock;
+
 use anyhow::Result;
 use async_trait::async_trait;
 
@@ -37,25 +40,31 @@ impl crate::Node for Node {
 /// A real backend would not implement the storage itself, but rather a way to retrieve the data
 /// from some storage mechansim (think IPFS), and thus `Clone`ing a backend is nothing esotheric.
 #[derive(Clone, Debug)]
-pub struct Backend(pub(crate) Vec<Option<Node>>);
+pub struct Backend(pub(crate) Arc<RwLock<Vec<Option<Node>>>>);
+
+impl Backend {
+    pub fn new(v: Vec<Option<Node>>) -> Self {
+        Backend(Arc::new(RwLock::new(v)))
+    }
+}
 
 #[async_trait]
 impl crate::DagBackend<Id, Node> for Backend {
     async fn get(&self, id: Id) -> Result<Option<Node>> {
-        if self.0.len() < id.0 + 1 {
+        if self.0.read().unwrap().len() < id.0 + 1 {
             Ok(None)
         } else {
-            Ok(self.0[id.0].clone())
+            Ok(self.0.read().unwrap()[id.0].clone())
         }
     }
 
     async fn put(&mut self, node: Node) -> Result<Id> {
-        while self.0.len() < node.id.0 + 1 {
-            self.0.push(None)
+        while self.0.read().unwrap().len() < node.id.0 + 1 {
+            self.0.write().unwrap().push(None)
         }
 
         let idx = node.id.0;
-        self.0[idx] = Some(node);
+        self.0.write().unwrap()[idx] = Some(node);
         Ok(Id(idx))
     }
 }