Add test for rebasing

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

1 files changed, 95 insertions, 0 deletions

diff --git a/src/async_dag.rs b/src/async_dag.rs
index 8b4c595..fb3bf3d 100644
--- a/src/async_dag.rs
+++ b/src/async_dag.rs
@@ -527,4 +527,99 @@ mod tests {
         assert_eq!(dag.backend.0.read().unwrap().len(), 4);
         assert_eq!(dag.head, test::Id(3));
     }
+
+    #[test]
+    fn test_rewrite_nodes() {
+        let mut dag = {
+            let head = test::Node {
+                parents: vec![test::Id(3)],
+                data: 4,
+            };
+            let b = test::Backend::new(vec![
+                test::Node {
+                    parents: vec![],
+                    data: 0,
+                },
+                test::Node {
+                    parents: vec![test::Id(0)],
+                    data: 1,
+                },
+                test::Node {
+                    parents: vec![test::Id(1)],
+                    data: 2,
+                },
+                test::Node {
+                    parents: vec![test::Id(2)],
+                    data: 3,
+                },
+                {
+                    head.clone()
+                }
+            ].into_iter().map(Some).collect());
+
+            let dag = tokio_test::block_on(AsyncDag::new(b, head));
+            assert!(dag.is_ok());
+            dag.unwrap()
+        };
+        assert_eq!(dag.backend.0.read().unwrap().len(), 5);
+        assert_eq!(dag.head, test::Id(4));
+
+        let rebase = dag.stream()
+            .take_while(|node| {
+                match node {
+                    Ok((id, _node)) => futures::future::ready(id.0 > 1), // the one we rebase on
+                    Err(_) => unreachable!(), // in tests this should be unreachable
+                }
+            })
+            .map(|node| {
+                let (_id, node) = node.unwrap(); // should never fail, same as above
+                test::Node {
+                    parents: vec![if node.parents[0] == test::Id(1) {
+                        test::Id(1) // base we rebase on
+                    } else {
+                        test::Id(node.parents[0].0 + 10)
+                    }],
+                    data: node.data + 10,
+                }
+            })
+            .collect::<Vec<_>>();
+
+        let rebase = tokio_test::block_on(rebase);
+        for node in rebase.into_iter().rev() { // reverse order here, because we apply from oldest in chain to newest
+            tokio_test::block_on(dag.update_head_unchecked(node)).unwrap();
+        }
+
+        // 15 because how the backend behaves
+        assert_eq!(dag.backend.0.read().unwrap().len(), 15);
+
+        // actual nodes:
+        //  * 5 original: 0 <- 1 <- 2 <- 3 <- 4
+        //  * 3 rewritten: 0 <- 1 <- 12 <- 13 <- 14
+        assert_eq!(dag.backend.0.read().unwrap().iter().filter(|n| n.is_some()).count(), 5 + 3);
+        assert_eq!(dag.head, test::Id(14));
+
+        {
+            let backend: &Vec<_> = &dag.backend.0.read().unwrap();
+
+            // test NONE <- 0
+            assert_eq!(backend.iter().filter_map(|n| n.as_ref()).find(|n| n.data == 0).unwrap().parents.len(), 0);
+
+            // test 0 <- 1
+            assert_eq!(backend.iter().filter_map(|n| n.as_ref()).find(|n| n.data == 1).unwrap().parents.len(), 1);
+            assert_eq!(backend.iter().filter_map(|n| n.as_ref()).find(|n| n.data == 1).unwrap().parents[0], test::Id(0));
+
+            // test 1 <- 12
+            assert_eq!(backend.iter().filter_map(|n| n.as_ref()).find(|n| n.data == 12).unwrap().parents.len(), 1);
+            assert_eq!(backend.iter().filter_map(|n| n.as_ref()).find(|n| n.data == 12).unwrap().parents[0], test::Id(1));
+
+            // test 12 <- 13
+            assert_eq!(backend.iter().filter_map(|n| n.as_ref()).find(|n| n.data == 13).unwrap().parents.len(), 1);
+            assert_eq!(backend.iter().filter_map(|n| n.as_ref()).find(|n| n.data == 13).unwrap().parents[0], test::Id(12));
+
+            // test 13 <- 14
+            assert_eq!(backend.iter().filter_map(|n| n.as_ref()).find(|n| n.data == 14).unwrap().parents.len(), 1);
+            assert_eq!(backend.iter().filter_map(|n| n.as_ref()).find(|n| n.data == 14).unwrap().parents[0], test::Id(13));
+        }
+    }
+
 }