diff --git a/.gitignore b/.gitignore
index a6a6eb96..dbc07079 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 target/
 **/*.rs.bk
 *.lock
+.direnv
diff --git a/crates/core/src/dom/program.rs b/crates/core/src/dom/program.rs
index d3b1758f..61eea9da 100644
--- a/crates/core/src/dom/program.rs
+++ b/crates/core/src/dom/program.rs
@@ -567,6 +567,7 @@ where
             new_vdom,
             &SkipPath::new(TreePath::root(), skip_diff.clone()),
         )
+        .unwrap()
     }
 
     #[cfg(feature = "with-raf")]
@@ -751,7 +752,7 @@ where
     }
 }
 
-fn create_dom_patch<Msg, F>(
+pub fn create_dom_patch<Msg, F>(
     root_node: &Rc<RefCell<Option<DomNode>>>,
     current_vdom: &vdom::Node<Msg>,
     new_vdom: &vdom::Node<Msg>,
@@ -761,7 +762,7 @@ where
     Msg: 'static,
     F: Fn(Msg) + 'static + Clone,
 {
-    let patches = diff(&current_vdom, new_vdom);
+    let patches = diff(&current_vdom, new_vdom).unwrap();
 
     #[cfg(all(feature = "with-debug", feature = "log-patches"))]
     {
@@ -790,6 +791,7 @@ where
         new_vdom: vdom::Node<APP::MSG>,
     ) -> Result<usize, JsValue> {
         let dom_patches = self.create_dom_patch(&new_vdom);
+
         let total_patches = dom_patches.len();
         self.pending_patches.borrow_mut().extend(dom_patches);
 
diff --git a/crates/core/src/vdom/diff.rs b/crates/core/src/vdom/diff.rs
index 1a0f4764..1ef527ce 100644
--- a/crates/core/src/vdom/diff.rs
+++ b/crates/core/src/vdom/diff.rs
@@ -13,6 +13,20 @@ static USE_SKIP_DIFF: bool = true;
 #[cfg(not(feature = "use-skipdiff"))]
 static USE_SKIP_DIFF: bool = false;
 
+/// all the possible error when diffing Node(s)
+#[derive(Debug, thiserror::Error, Clone, Copy)]
+pub enum DiffError {
+    /// Node list must have already unrolled when creating an element
+    #[error("Node list must have already unrolled when creating an element")]
+    UnrollError,
+    /// Skip diff error
+    #[error("Skip diff error")]
+    SkipDiffError,
+    /// Invalid root node count of: {0}
+    #[error("Invalid root node count of: {0}")]
+    InvalidRootNodeCount(usize),
+}
+
 /// Return the patches needed for `old_node` to have the same DOM as `new_node`
 ///
 /// # Agruments
@@ -40,7 +54,7 @@ static USE_SKIP_DIFF: bool = false;
 ///     vec![element("div", vec![attr("key", "2")], vec![])],
 /// );
 ///
-/// let diff = diff(&old, &new);
+/// let diff = diff(&old, &new).unwrap();
 /// assert_eq!(
 ///     diff,
 ///     vec![Patch::remove_node(
@@ -50,7 +64,10 @@ static USE_SKIP_DIFF: bool = false;
 ///     ]
 /// );
 /// ```
-pub fn diff<'a, MSG>(old_node: &'a Node<MSG>, new_node: &'a Node<MSG>) -> Vec<Patch<'a, MSG>> {
+pub fn diff<'a, MSG>(
+    old_node: &'a Node<MSG>,
+    new_node: &'a Node<MSG>,
+) -> Result<Vec<Patch<'a, MSG>>, DiffError> {
     diff_recursive(
         old_node,
         new_node,
@@ -115,10 +132,10 @@ pub fn diff_recursive<'a, MSG>(
     old_node: &'a Node<MSG>,
     new_node: &'a Node<MSG>,
     path: &SkipPath,
-) -> Vec<Patch<'a, MSG>> {
+) -> Result<Vec<Patch<'a, MSG>>, DiffError> {
     if let Some(skip_diff) = path.skip_diff.as_ref() {
         if USE_SKIP_DIFF && skip_diff.shall_skip_node() {
-            return vec![];
+            return Err(DiffError::SkipDiffError);
         }
     }
 
@@ -136,16 +153,31 @@ pub fn diff_recursive<'a, MSG>(
     };
     // skip diffing if the function evaluates to true
     if skip(old_node, new_node) {
-        return vec![];
+        return Ok(vec![]);
+    }
+
+    // multiple root nodes are not supported. this would be two root nodes "<div></div><div></div>"
+    // the diff will work but the result is wrong, so instead we bail out here
+    match new_node {
+        Node::Leaf(leaf) => match leaf {
+            Leaf::NodeList(list) => {
+                if list.len() > 1 {
+                    log::error!("invalid root node cound: input needs exactly one root node and childs, not several root nodes");
+                    return Err(DiffError::InvalidRootNodeCount(list.len()));
+                }
+            }
+            _ => {}
+        },
+        Node::Element(_) => {}
     }
 
     // replace node and return early
     if should_replace(old_node, new_node) {
-        return vec![Patch::replace_node(
+        return Ok(vec![Patch::replace_node(
             old_node.tag(),
             path.path.clone(),
             vec![new_node],
-        )];
+        )]);
     }
 
     let mut patches = vec![];
@@ -169,10 +201,13 @@ pub fn diff_recursive<'a, MSG>(
                     // we back track since Fragment is not a real node, but it would still
                     // be traversed from the prior call
                     let patch = diff_nodes(None, old_nodes, new_nodes, &path.backtrack());
-                    patches.extend(patch);
+                    match patch {
+                        Ok(patch) => patches.extend(patch),
+                        Err(e) => return Err(e),
+                    };
                 }
                 (Leaf::NodeList(_old_elements), Leaf::NodeList(_new_elements)) => {
-                    panic!("Node list must have already unrolled when creating an element");
+                    return Err(DiffError::UnrollError)
                 }
                 (Leaf::StatelessComponent(old_comp), Leaf::StatelessComponent(new_comp)) => {
                     let new_path = SkipPath {
@@ -192,7 +227,10 @@ pub fn diff_recursive<'a, MSG>(
                         "new comp view should not be a template"
                     );
                     let patch = diff_recursive(old_real_view, new_real_view, &new_path);
-                    patches.extend(patch);
+                    match patch {
+                        Ok(patch) => patches.extend(patch),
+                        Err(e) => return Err(e),
+                    }
                 }
                 (Leaf::StatefulComponent(old_comp), Leaf::StatefulComponent(new_comp)) => {
                     let attr_patches = create_attribute_patches(
@@ -201,15 +239,26 @@ pub fn diff_recursive<'a, MSG>(
                         &new_comp.attrs,
                         path,
                     );
-                    if !attr_patches.is_empty() {
-                        log::info!("stateful component attr_patches: {attr_patches:#?}");
-                    }
-                    patches.extend(attr_patches);
-                    let patch = diff_nodes(None, &old_comp.children, &new_comp.children, path);
-                    if !patch.is_empty() {
-                        log::info!("stateful component patch: {patch:#?}");
+                    match attr_patches {
+                        Ok(attr_patches) => {
+                            if !attr_patches.is_empty() {
+                                log::info!("stateful component attr_patches: {attr_patches:#?}");
+                            }
+                            patches.extend(attr_patches);
+                            let patch =
+                                diff_nodes(None, &old_comp.children, &new_comp.children, path);
+                            match patch {
+                                Ok(patch) => {
+                                    if !patch.is_empty() {
+                                        log::info!("stateful component patch: {patch:#?}");
+                                    }
+                                    patches.extend(patch);
+                                }
+                                Err(e) => return Err(e),
+                            }
+                        }
+                        Err(e) => return Err(e),
                     }
-                    patches.extend(patch);
                 }
                 (Leaf::TemplatedView(_old_view), _) => {
                     unreachable!("templated view should not be diffed..")
@@ -238,7 +287,10 @@ pub fn diff_recursive<'a, MSG>(
                     new_element.attributes(),
                     path,
                 );
-                patches.extend(attr_patches);
+                match attr_patches {
+                    Ok(attr_patches) => patches.extend(attr_patches),
+                    Err(e) => return Err(e),
+                };
             }
 
             let more_patches = diff_nodes(
@@ -247,15 +299,17 @@ pub fn diff_recursive<'a, MSG>(
                 new_element.children(),
                 path,
             );
-
-            patches.extend(more_patches);
+            match more_patches {
+                Ok(more_patches) => patches.extend(more_patches),
+                Err(e) => return Err(e),
+            };
         }
         _ => {
             unreachable!("Unequal variant discriminants should already have been handled");
         }
     };
 
-    patches
+    Ok(patches)
 }
 
 fn diff_nodes<'a, MSG>(
@@ -263,12 +317,12 @@ fn diff_nodes<'a, MSG>(
     old_children: &'a [Node<MSG>],
     new_children: &'a [Node<MSG>],
     path: &SkipPath,
-) -> Vec<Patch<'a, MSG>> {
+) -> Result<Vec<Patch<'a, MSG>>, DiffError> {
     let diff_as_keyed = is_any_keyed(old_children) || is_any_keyed(new_children);
 
     if diff_as_keyed {
         let keyed_patches = diff_lis::diff_keyed_nodes(old_tag, old_children, new_children, path);
-        keyed_patches
+        Ok(keyed_patches)
     } else {
         let non_keyed_patches = diff_non_keyed_nodes(old_tag, old_children, new_children, path);
         non_keyed_patches
@@ -290,14 +344,17 @@ fn diff_non_keyed_nodes<'a, MSG>(
     old_children: &'a [Node<MSG>],
     new_children: &'a [Node<MSG>],
     path: &SkipPath,
-) -> Vec<Patch<'a, MSG>> {
-    let mut patches = vec![];
+) -> Result<Vec<Patch<'a, MSG>>, DiffError> {
+    let mut patches: Vec<Patch<'a, MSG>> = vec![];
     let old_child_count = old_children.len();
     let new_child_count = new_children.len();
 
     // if there is no new children, then clear the children of this element
     if old_child_count > 0 && new_child_count == 0 {
-        return vec![Patch::clear_children(old_element_tag, path.path.clone())];
+        return Ok(vec![Patch::clear_children(
+            old_element_tag,
+            path.path.clone(),
+        )]);
     }
 
     let min_count = cmp::min(old_child_count, new_child_count);
@@ -309,7 +366,10 @@ fn diff_non_keyed_nodes<'a, MSG>(
         let new_child = &new_children.get(index).expect("No new child node");
 
         let more_patches = diff_recursive(old_child, new_child, &child_path);
-        patches.extend(more_patches);
+        match more_patches {
+            Ok(more_patches) => patches.extend(more_patches),
+            Err(e) => return Err(e),
+        }
     }
 
     // If there are more new child than old_node child, we make a patch to append the excess element
@@ -335,7 +395,7 @@ fn diff_non_keyed_nodes<'a, MSG>(
         patches.extend(remove_node_patches);
     }
 
-    patches
+    Ok(patches)
 }
 
 ///
@@ -348,7 +408,7 @@ fn create_attribute_patches<'a, MSG>(
     old_attributes: &'a [Attribute<MSG>],
     new_attributes: &'a [Attribute<MSG>],
     path: &SkipPath,
-) -> Vec<Patch<'a, MSG>> {
+) -> Result<Vec<Patch<'a, MSG>>, DiffError> {
     let skip_indices = if let Some(skip_diff) = &path.skip_diff {
         if let SkipAttrs::Indices(skip_indices) = &skip_diff.skip_attrs {
             skip_indices.clone()
@@ -365,7 +425,7 @@ fn create_attribute_patches<'a, MSG>(
 
     // return early if both attributes are empty
     if old_attributes.is_empty() && new_attributes.is_empty() {
-        return vec![];
+        return Ok(vec![]);
     }
 
     let mut add_attributes: Vec<&Attribute<MSG>> = vec![];
@@ -440,7 +500,7 @@ fn create_attribute_patches<'a, MSG>(
             remove_attributes,
         ));
     }
-    patches
+    Ok(patches)
 }
 
 /// returns true if all the elements in subset is in big_set
diff --git a/crates/core/src/vdom/diff_lis.rs b/crates/core/src/vdom/diff_lis.rs
index 8926a3d9..b33f3973 100644
--- a/crates/core/src/vdom/diff_lis.rs
+++ b/crates/core/src/vdom/diff_lis.rs
@@ -112,7 +112,7 @@ fn diff_keyed_ends<'a, MSG>(
         }
         let child_path = path.traverse(index);
         // diff the children and add to patches
-        let patches = diff_recursive(old, new, &child_path);
+        let patches = diff_recursive(old, new, &child_path).unwrap();
         all_patches.extend(patches);
         old_index_matched.push(index);
         left_offset += 1;
@@ -158,7 +158,7 @@ fn diff_keyed_ends<'a, MSG>(
             break;
         }
         let child_path = path.traverse(old_index);
-        let patches = diff_recursive(old, new, &child_path);
+        let patches: Vec<Patch<'a, MSG>> = diff_recursive(old, new, &child_path).unwrap();
         all_patches.extend(patches);
         right_offset += 1;
     }
@@ -281,11 +281,12 @@ fn diff_keyed_middle<'a, MSG>(
     }
 
     for idx in lis_sequence.iter() {
-        let patches = diff_recursive(
+        let patches: Vec<Patch<'a, MSG>> = diff_recursive(
             &old_children[new_index_to_old_index[*idx]],
             &new_children[*idx],
             path,
-        );
+        )
+        .unwrap();
         all_patches.extend(patches);
     }
 
@@ -301,7 +302,8 @@ fn diff_keyed_middle<'a, MSG>(
             if old_index == u32::MAX as usize {
                 new_nodes.push(new_node);
             } else {
-                let patches = diff_recursive(&old_children[old_index], new_node, path);
+                let patches: Vec<Patch<'a, MSG>> =
+                    diff_recursive(&old_children[old_index], new_node, path).unwrap();
                 all_patches.extend(patches);
 
                 node_paths.push(path.traverse(left_offset + old_index).path);
@@ -339,7 +341,8 @@ fn diff_keyed_middle<'a, MSG>(
             if old_index == u32::MAX as usize {
                 new_nodes.push(new_node)
             } else {
-                let patches = diff_recursive(&old_children[old_index], new_node, path);
+                let patches: Vec<Patch<'a, MSG>> =
+                    diff_recursive(&old_children[old_index], new_node, path).unwrap();
                 all_patches.extend(patches);
             }
         }
@@ -363,7 +366,8 @@ fn diff_keyed_middle<'a, MSG>(
             if old_index == u32::MAX as usize {
                 new_nodes.push(new_node);
             } else {
-                let patches = diff_recursive(&old_children[old_index], new_node, path);
+                let patches: Vec<Patch<'a, MSG>> =
+                    diff_recursive(&old_children[old_index], new_node, path).unwrap();
                 all_patches.extend(patches);
                 node_paths.push(path.traverse(left_offset + old_index).path);
             }
diff --git a/examples/patch_dom_node/src/main.rs b/examples/patch_dom_node/src/main.rs
index d43c3dea..f83d7a43 100644
--- a/examples/patch_dom_node/src/main.rs
+++ b/examples/patch_dom_node/src/main.rs
@@ -32,7 +32,7 @@ fn main() {
     let root = dom::create_dom_node(&old_node, ev_callback);
     let root_node = Rc::new(RefCell::new(Some(root)));
 
-    let vdom_patches = vdom::diff(&old_node, &new_node);
+    let vdom_patches = vdom::diff(&old_node, &new_node).unwrap();
     log::info!("Created {} VDOM patch(es)", vdom_patches.len());
     log::debug!("VDOM patch(es): {vdom_patches:?}");
 
diff --git a/tests/dom_diff_with_events.rs b/tests/dom_diff_with_events.rs
index 7c6d63d5..75bfbfaa 100644
--- a/tests/dom_diff_with_events.rs
+++ b/tests/dom_diff_with_events.rs
@@ -21,7 +21,7 @@ fn nodes_with_event_should_not_recycle() {
         vec![div(vec![class("child")], vec![])],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     log::info!("{:#?}", diff);
     assert_eq!(
         diff,
diff --git a/tests/dom_event_tests.rs b/tests/dom_event_tests.rs
index a3e218c2..8d810124 100644
--- a/tests/dom_event_tests.rs
+++ b/tests/dom_event_tests.rs
@@ -135,7 +135,7 @@ fn remove_event() {
         ],
         vec![],
     );
-    let patch = diff(&old, &new);
+    let patch = diff(&old, &new).unwrap();
     log::debug!("patch: {:?}", patch);
 
     let input_event = web_sys::InputEvent::new("input").unwrap();
diff --git a/tests/dom_insert_before_after_patches.rs b/tests/dom_insert_before_after_patches.rs
index 09caec9d..3aa5f077 100644
--- a/tests/dom_insert_before_after_patches.rs
+++ b/tests/dom_insert_before_after_patches.rs
@@ -16,34 +16,14 @@ fn insert_multiple_before_nodes() {
 
     let document = web_sys::window().unwrap().document().unwrap();
 
-    let old: Node<()> = main(
-        vec![class("before_nodes_test1")],
-        vec![ul(
-            vec![class("todo")],
-            vec![
-                li(vec![key(1)], vec![text("item1")]),
-                li(vec![key(2)], vec![text("item2")]),
-                li(vec![key(3)], vec![text("item3")]),
-            ],
-        )],
-    );
+    let old: Node<()> = raw_html::<()>("<div id=\"there\"></div>");
 
-    let update1: Node<()> = main(
-        vec![class("before_nodes_test1")],
-        vec![ul(
-            vec![class("todo")],
-            vec![
-                li(vec![], vec![text("itemA")]),
-                li(vec![], vec![text("itemB")]),
-                li(vec![], vec![text("itemC")]),
-                li(vec![key(1)], vec![text("item1")]),
-                li(vec![key(2)], vec![text("item2")]),
-                li(vec![key(3)], vec![text("item3")]),
-            ],
-        )],
-    );
+    let update1: Node<()> =
+        raw_html::<()>("<div id=\"there\"><div><div><div><div></div></div></div></div></div>");
+
+    let update2: Node<()> = raw_html::<()>("<div id=\"there\"><b>foo</b></div>");
 
-    let patches = diff(&old, &update1);
+    let patches = diff(&old, &update1).unwrap();
     log::debug!("patches: {:#?}", patches);
 
     let mut old_html = String::new();
@@ -55,26 +35,43 @@ fn insert_multiple_before_nodes() {
         .update_dom_with_vdom(old)
         .expect("must update dom");
 
-    let container = document
-        .query_selector(".before_nodes_test1")
-        .expect("must not error")
-        .expect("must exist");
+    // let container = document
+    //     .query_selector(".before_nodes_test1")
+    //     .expect("must not error")
+    //     .expect("must exist");
 
-    let expected = "<main class=\"before_nodes_test1\"><ul class=\"todo\"><li key=\"1\">item1</li><li key=\"2\">item2</li><li key=\"3\">item3</li></ul></main>";
-    assert_eq!(expected, container.outer_html());
+    // let expected = "<main class=\"before_nodes_test1\"><ul class=\"todo\"><li key=\"1\">item1</li><li key=\"2\">item2</li><li key=\"3\">item3</li></ul></main>";
+    // assert_eq!(expected, container.outer_html());
 
     simple_program
         .update_dom_with_vdom(update1)
         .expect("must not error");
 
-    let container = document
-        .query_selector(".before_nodes_test1")
-        .expect("must not error")
-        .expect("must exist");
+    // let container = document
+    //     .query_selector(".before_nodes_test1")
+    //     .expect("must not error")
+    //     .expect("must exist");
+
+    // let expected1 = "<main class=\"before_nodes_test1\"><ul class=\"todo\"><li>itemA</li><li>itemB</li><li>itemC</li><li key=\"1\">item1</li><li key=\"2\">item2</li><li key=\"3\">item3</li></ul></main>";
+
+    // assert_eq!(expected1, container.outer_html());
+
+    simple_program
+        .update_dom_with_vdom(update2)
+        .expect("must not error");
+
+    //let container = document.body().expect("must not error");
+    let container = document.get_element_by_id("there").unwrap();
+
+    // let container = document
+    //     .query_selector(".before_nodes_test1")
+    //     .expect("must not error")
+    //     .expect("must exist");
 
-    let expected1 = "<main class=\"before_nodes_test1\"><ul class=\"todo\"><li>itemA</li><li>itemB</li><li>itemC</li><li key=\"1\">item1</li><li key=\"2\">item2</li><li key=\"3\">item3</li></ul></main>";
+    let expected1 = "<div id=\"there\"><b>foo</b></div>";
 
     assert_eq!(expected1, container.outer_html());
+    assert_eq!(1, 2);
 }
 
 #[wasm_bindgen_test]
@@ -111,7 +108,7 @@ fn insert_multiple_after_nodes() {
         )],
     );
 
-    let patches = diff(&old, &update1);
+    let patches = diff(&old, &update1).unwrap();
     log::debug!("patches: {:#?}", patches);
 
     let mut old_html = String::new();
@@ -179,7 +176,7 @@ fn insert_multiple_in_the_middle() {
         )],
     );
 
-    let patches = diff(&old, &update1);
+    let patches = diff(&old, &update1).unwrap();
     log::debug!("patching old to update1: {:#?}", patches);
 
     let mut old_html = String::new();
diff --git a/tests/dom_insert_patches.rs b/tests/dom_insert_patches.rs
index 8b97cd69..8a77bd63 100644
--- a/tests/dom_insert_patches.rs
+++ b/tests/dom_insert_patches.rs
@@ -41,7 +41,7 @@ fn test_patch_insert_node() {
         )],
     );
 
-    let patches = diff(&old, &update1);
+    let patches = diff(&old, &update1).unwrap();
     log::debug!("patches: {:#?}", patches);
 
     let mut old_html = String::new();
@@ -108,7 +108,7 @@ fn test_patch_insert_node_in_the_middle() {
         )],
     );
 
-    let patches = diff(&old, &update1);
+    let patches = diff(&old, &update1).unwrap();
     log::debug!("patches: {:#?}", patches);
 
     let mut old_html = String::new();
@@ -179,7 +179,7 @@ fn multiple_insert_should_work() {
         )],
     );
 
-    let patches = diff(&old, &update1);
+    let patches = diff(&old, &update1).unwrap();
     log::debug!("patches: {:#?}", patches);
 
     let mut old_html = String::new();
diff --git a/tests/dom_keyed_subsequent_updates.rs b/tests/dom_keyed_subsequent_updates.rs
index c145825f..8af21237 100644
--- a/tests/dom_keyed_subsequent_updates.rs
+++ b/tests/dom_keyed_subsequent_updates.rs
@@ -111,7 +111,7 @@ fn subsequent_updates() {
         ],
     );
 
-    let patches1 = diff(&old, &update1);
+    let patches1 = diff(&old, &update1).unwrap();
 
     log::trace!("patches1: {:#?} at line: {}", patches1, line!());
 
@@ -276,7 +276,7 @@ fn subsequent_updates() {
         let root_node_html = root_node.as_ref().unwrap().outer_html();
         log::trace!("current root node: {}", root_node_html);
     }
-    let patches2 = diff(&update1, &update2);
+    let patches2 = diff(&update1, &update2).unwrap();
     log::trace!("-->patches2: {:#?}", patches2);
 
     log::info!("Updating dom with update2");
@@ -381,7 +381,7 @@ fn subsequent_updates() {
         ],
     );
 
-    let patches3 = diff(&update2, &update3);
+    let patches3 = diff(&update2, &update3).unwrap();
     log::trace!("\n---->patches3: {:#?}", patches3);
 
     simple_program
diff --git a/tests/dom_node_event_recycling.rs b/tests/dom_node_event_recycling.rs
index d0dfcfb7..659e0acc 100644
--- a/tests/dom_node_event_recycling.rs
+++ b/tests/dom_node_event_recycling.rs
@@ -40,7 +40,7 @@ fn elements_with_different_event_should_not_be_recycle() {
     log::info!("cb2: {:#?}", cb2);
     let new = input(vec![id(elem_id), cb2.clone()], vec![]);
 
-    let patches: Vec<Patch<()>> = diff(&old, &new);
+    let patches: Vec<Patch<()>> = diff(&old, &new).unwrap();
     // FIXME: this should replace the old node with a new one since the even essentially is a new
     // one. But we have no way of knowing the closure will produce the same result of not
     log::trace!("patches: {:#?}", patches);
diff --git a/tests/dom_passing_reordered_keyed_node.rs b/tests/dom_passing_reordered_keyed_node.rs
index 730f6226..5e51b8e4 100644
--- a/tests/dom_passing_reordered_keyed_node.rs
+++ b/tests/dom_passing_reordered_keyed_node.rs
@@ -34,7 +34,7 @@ fn reordered_keys2() {
         )],
     );
 
-    let patches = diff(&old, &update1);
+    let patches = diff(&old, &update1).unwrap();
     log::debug!("patches: {:#?}", patches);
 
     let mut old_html = String::new();
@@ -92,7 +92,7 @@ fn reordered_keys3() {
         )],
     );
 
-    let patches = diff(&old, &update1);
+    let patches = diff(&old, &update1).unwrap();
     log::debug!("patches: {:#?}", patches);
 
     let mut old_html = String::new();
diff --git a/tests/dom_patches_keyed.rs b/tests/dom_patches_keyed.rs
index d62c27aa..9e71bbe3 100644
--- a/tests/dom_patches_keyed.rs
+++ b/tests/dom_patches_keyed.rs
@@ -78,7 +78,7 @@ fn node_patched_properly() {
         )],
     );
 
-    let patches = diff(&old, &update1);
+    let patches = diff(&old, &update1).unwrap();
     log::debug!("patches: {:#?}", patches);
     let mut old_html = String::new();
     old.render(&mut old_html).expect("must render");
@@ -151,7 +151,7 @@ fn node_patched_properly_remove_from_start() {
         )],
     );
 
-    let patches = diff(&old, &update1);
+    let patches = diff(&old, &update1).unwrap();
 
     log::debug!("patches: {:#?}", patches);
 
@@ -228,7 +228,7 @@ fn node_patched_properly_text_changed() {
         )],
     );
 
-    let patches = diff(&old, &update1);
+    let patches = diff(&old, &update1).unwrap();
     log::debug!("patches: {:#?}", patches);
 
     let mut old_html = String::new();
@@ -310,7 +310,7 @@ fn mixed_keyed_and_non_keyed_elements() {
         ],
     );
 
-    let patches = diff(&old, &update1);
+    let patches = diff(&old, &update1).unwrap();
     log::debug!("patches: {:#?}", patches);
 
     let mut old_html = String::new();
diff --git a/tests/dom_patches_text_node.rs b/tests/dom_patches_text_node.rs
index 690553d3..96c2b8e3 100644
--- a/tests/dom_patches_text_node.rs
+++ b/tests/dom_patches_text_node.rs
@@ -30,7 +30,7 @@ fn patches_text() {
         )],
     );
 
-    let patches = diff(&old, &update1);
+    let patches = diff(&old, &update1).unwrap();
     log::debug!("patches: {:#?}", patches);
 
     let mut old_html = String::new();
diff --git a/tests/dom_remove_node_patches.rs b/tests/dom_remove_node_patches.rs
index 2862a2e1..af116c01 100644
--- a/tests/dom_remove_node_patches.rs
+++ b/tests/dom_remove_node_patches.rs
@@ -39,7 +39,7 @@ fn test_remove_nodes() {
         )],
     );
 
-    let patches = diff(&old, &update1);
+    let patches = diff(&old, &update1).unwrap();
     log::debug!("patches: {:#?}", patches);
 
     let mut old_html = String::new();
diff --git a/tests/dom_reordered_keyed_nodes.rs b/tests/dom_reordered_keyed_nodes.rs
index dc346ae6..8332eca2 100644
--- a/tests/dom_reordered_keyed_nodes.rs
+++ b/tests/dom_reordered_keyed_nodes.rs
@@ -40,7 +40,7 @@ fn failing_reordered_keys() {
     // The patch was:
     //  append key1, item1
     //  remove nodeidx: 2, [0,0,0]
-    let patches = diff(&old, &update1);
+    let patches = diff(&old, &update1).unwrap();
     log::debug!("patches: {:#?}", patches);
 
     let mut old_html = String::new();
diff --git a/tests/dom_replace_node_patches.rs b/tests/dom_replace_node_patches.rs
index b56e4306..87923992 100644
--- a/tests/dom_replace_node_patches.rs
+++ b/tests/dom_replace_node_patches.rs
@@ -41,7 +41,7 @@ fn test_multiple_replace() {
         )],
     );
 
-    let patches = diff(&old, &update1);
+    let patches = diff(&old, &update1).unwrap();
     log::debug!("patches: {:#?}", patches);
 
     let mut old_html = String::new();
@@ -107,7 +107,7 @@ fn test_multiple_replace_and_parent_is_replaced_too() {
         )],
     );
 
-    let patches = diff(&old, &update1);
+    let patches = diff(&old, &update1).unwrap();
     log::debug!("patches: {:#?}", patches);
 
     let mut old_html = String::new();
diff --git a/tests/dom_swap_nodes.rs b/tests/dom_swap_nodes.rs
index 330d7608..d580b90f 100644
--- a/tests/dom_swap_nodes.rs
+++ b/tests/dom_swap_nodes.rs
@@ -47,7 +47,7 @@ fn swap_rows_non_keyed() {
         )],
     );
 
-    let patches = diff(&old, &update1);
+    let patches = diff(&old, &update1).unwrap();
     log::debug!("patches: {:#?}", patches);
 
     let mut old_html = String::new();
@@ -108,7 +108,7 @@ fn swap_rows_keyed() {
         )],
     );
 
-    let patches = diff(&old, &update1);
+    let patches = diff(&old, &update1).unwrap();
     log::debug!("patches: {:#?}", patches);
 
     let mut old_html = String::new();
@@ -179,7 +179,7 @@ fn swap_1_and_8() {
         )],
     );
 
-    let patches = diff(&old, &update1);
+    let patches = diff(&old, &update1).unwrap();
     log::debug!("patches: {:#?}", patches);
 
     let mut old_html = String::new();
diff --git a/tests/dom_test_update.rs b/tests/dom_test_update.rs
index ef89ca28..3c85a68d 100644
--- a/tests/dom_test_update.rs
+++ b/tests/dom_test_update.rs
@@ -98,7 +98,7 @@ fn test1() {
      </div>
     );
 
-    let patch = diff(&current_dom, &target_dom);
+    let patch = diff(&current_dom, &target_dom).unwrap();
 
     log::trace!("test update here..");
     log::debug!("patches: {:#?}", patch);
diff --git a/tests/dom_updates_target_dom.rs b/tests/dom_updates_target_dom.rs
index 4ed8324e..75189d9a 100644
--- a/tests/dom_updates_target_dom.rs
+++ b/tests/dom_updates_target_dom.rs
@@ -105,7 +105,7 @@ fn multiple_match_on_keyed_elements() {
     </div>
     );
 
-    let patches = diff(&current_dom, &target_dom);
+    let patches = diff(&current_dom, &target_dom).unwrap();
     log::trace!("patches: {:#?}", patches);
 
     log::trace!("current_dom: {}", current_dom.render_to_string());
diff --git a/tests/dom_vdom_standalone.rs b/tests/dom_vdom_standalone.rs
index b3131ce6..690cd951 100644
--- a/tests/dom_vdom_standalone.rs
+++ b/tests/dom_vdom_standalone.rs
@@ -1,4 +1,5 @@
 use std::{cell::RefCell, rc::Rc};
+use wasm_bindgen_test::*;
 
 use wasm_bindgen_test::*;
 use web_sys::{Element, HtmlElement};
@@ -20,8 +21,6 @@ fn test_dom_vdom_standalone() {
     console_log::init_with_level(log::Level::Trace).unwrap();
     console_error_panic_hook::set_once();
 
-    let ev_callback = |_| {};
-
     let window = web_sys::window().expect("no global `window` exists");
     let document = window.document().expect("should have a document on window");
 
@@ -31,7 +30,6 @@ fn test_dom_vdom_standalone() {
 
     let web_sys_node: web_sys::Node = web_sys::Node::from(div);
     let div_node = DomNode::from(web_sys_node);
-    let mount_node = Rc::new(RefCell::new(Some(div_node)));
 
     let new_html = r#"
     <div>boak</div>
@@ -39,14 +37,15 @@ fn test_dom_vdom_standalone() {
 
     let old_node: Node<()> = parse_html::<()>("").unwrap().unwrap();
     let new_node: Node<()> = raw_html::<()>(new_html);
-    let root = dom::create_dom_node(&old_node, ev_callback);
-    let root_node = Rc::new(RefCell::new(Some(root)));
 
-    let vdom_patches = vdom::diff(&old_node, &new_node);
+    let vdom_patches = vdom::diff(&old_node, &new_node).unwrap();
     log::debug!("Created {} VDOM patch(es)", vdom_patches.len());
     log::debug!("Created {:?}", vdom_patches);
 
-    // convert vdom patch to real dom patches
+    let ev_callback = |_| {};
+    let root: DomNode = dom::create_dom_node(&old_node, ev_callback);
+    let root_node: Rc<RefCell<Option<DomNode>>> = Rc::new(RefCell::new(Some(root)));
+
     let dom_patches = dom::convert_patches(
         &root_node.borrow().as_ref().unwrap(),
         &vdom_patches,
@@ -56,12 +55,118 @@ fn test_dom_vdom_standalone() {
     log::debug!("Converted {} DOM patch(es)", dom_patches.len());
     log::debug!("Converted {:?}", dom_patches);
 
+    let mount_node: Rc<RefCell<Option<DomNode>>> = Rc::new(RefCell::new(Some(div_node)));
     dom::apply_dom_patches(root_node, mount_node, dom_patches).unwrap();
 
     let target: Element = document.get_element_by_id("here").unwrap();
-
-    // Get the inner HTML from the body element
     let html_content: String = target.inner_html();
 
     assert_eq!("<div>boak</div>".to_string(), html_content);
 }
+
+
+#[derive(Clone)]
+struct DomUpdater {
+    id: String,
+    current_vdom: Node<()>,
+    root_node: Rc<RefCell<Option<DomNode>>>,
+    mount_node: Rc<RefCell<Option<DomNode>>>,
+}
+
+impl DomUpdater {
+    fn new(id: String) -> Self {
+        let window = web_sys::window().expect("no global `window` exists");
+        let document = window.document().expect("should have a document on window");
+
+        let div: web_sys::Element = document.create_element("div").unwrap();
+        div.set_attribute("id", id.as_str()).unwrap();
+        document.body().unwrap().append_child(&div).unwrap();
+
+        let web_sys_node: web_sys::Node = web_sys::Node::from(div);
+        let div_node = DomNode::from(web_sys_node);
+
+        let current_vdom: Node<()> = parse_html::<()>("").unwrap().unwrap();
+        let ev_callback = |_| {};
+        let root: DomNode = dom::create_dom_node(&current_vdom, ev_callback);
+
+        DomUpdater {
+            id,
+            current_vdom,
+            root_node: Rc::new(RefCell::new(Some(root))),
+            mount_node: Rc::new(RefCell::new(Some(div_node))),
+        }
+    }
+    fn update(&mut self, next_html: String) {
+        let new_node: Node<()> = parse_html::<()>(next_html.as_str()).unwrap().unwrap();
+
+        let old_vdom = self.current_vdom.clone();
+
+        log::debug!("-------------------------------------------------");
+        log::debug!("old_node: {}", old_vdom.render_to_string());
+        log::debug!("inner_html: {}", self.inner_html());
+        fn same(a: String, b: String) -> String {
+            if a == b {
+                "same".to_string()
+            } else {
+                "different".to_string()
+            }
+        }
+        log::debug!(
+            "   => {}",
+            same(old_vdom.render_to_string(), self.inner_html())
+        );
+        log::debug!("new_node: {}", new_node.render_to_string());
+        log::debug!("new_node: {:#?}", new_node);
+
+        let vdom_patches = vdom::diff(&old_vdom, &new_node).unwrap();
+
+        log::debug!("Created {} VDOM patch(es)", vdom_patches.len());
+        log::debug!("Created {:#?}", vdom_patches);
+        let dom_patches = dom::convert_patches(
+            self.root_node.borrow().as_ref().unwrap(),
+            &vdom_patches,
+            |_| {},
+        )
+        .unwrap();
+        log::debug!("Converted {} DOM patch(es)", dom_patches.len());
+        log::debug!("Converted {:#?}", dom_patches);
+        log::debug!("-------------------------------------------------");
+        dom::apply_dom_patches(
+            Rc::clone(&self.root_node),
+            Rc::clone(&self.mount_node),
+            dom_patches,
+        )
+        .unwrap();
+        self.current_vdom = new_node.clone();
+
+        assert_eq!(next_html, self.inner_html());
+    }
+    fn inner_html(&self) -> String {
+        let window = web_sys::window().expect("no global `window` exists");
+        let document = window.document().expect("should have a document on window");
+        let target: Element = document.get_element_by_id(self.id.as_str()).unwrap();
+        target.inner_html()
+    }
+}
+
+#[wasm_bindgen_test]
+fn test_dom_vdom_patcher() {
+    console_log::init_with_level(log::Level::Trace).ok();
+    console_error_panic_hook::set_once();
+    let id: String = "there".to_string();
+
+    let mut dom_updater: DomUpdater = DomUpdater::new(id.clone());
+
+    let html: String = "<div id=\"there\"></div>".to_string();
+    dom_updater.update(html.clone());
+    assert_eq!(html.to_string(), dom_updater.inner_html());
+
+    let html: String = "<div></div>".to_string();
+    dom_updater.update(html.clone());
+    assert_eq!(html, dom_updater.inner_html());
+
+    let html: String = "<div id=\"there\"><b>foo</b></div>".to_string();
+    dom_updater.update(html.clone());
+
+    assert_eq!(html, dom_updater.inner_html());
+}
diff --git a/tests/html_diff_classes.rs b/tests/html_diff_classes.rs
index 684681f2..254b77ee 100644
--- a/tests/html_diff_classes.rs
+++ b/tests/html_diff_classes.rs
@@ -7,7 +7,7 @@ fn class_with_bool_value() {
 
     let new = div(vec![class(true)], vec![]);
     assert_eq!(
-        diff(&old, &new),
+        diff(&old, &new).unwrap(),
         vec![Patch::add_attributes(
             &"div",
             TreePath::new(vec![]),
@@ -37,7 +37,7 @@ fn parent_of_matching_keyed_are_ignored() {
         ],
     );
     assert_eq!(
-        diff(&old, &new),
+        diff(&old, &new).unwrap(),
         vec![Patch::add_attributes(
             &"ul",
             TreePath::new(vec![]),
diff --git a/tests/html_diff_patch_test.rs b/tests/html_diff_patch_test.rs
index 056d148c..f190d729 100644
--- a/tests/html_diff_patch_test.rs
+++ b/tests/html_diff_patch_test.rs
@@ -28,7 +28,7 @@ fn nodes_with_event_must_be_replaced() {
         ],
         vec![],
     );
-    let patch = diff(&old, &new);
+    let patch = diff(&old, &new).unwrap();
     println!("patch: {:#?}", patch);
 
     assert_eq!(
@@ -47,7 +47,7 @@ fn change_class_attribute() {
 
     let new = div(vec![classes(["class1", "difference_class"])], vec![]);
     assert_eq!(
-        diff(&old, &new),
+        diff(&old, &new).unwrap(),
         vec![Patch::add_attributes(
             &"div",
             TreePath::new(vec![]),
@@ -88,7 +88,7 @@ fn truncate_children() {
         ],
     );
     assert_eq!(
-        dbg!(diff(&old, &new)),
+        dbg!(diff(&old, &new)).unwrap(),
         vec![
             Patch::remove_node(Some(&"div"), TreePath::new(vec![3]),),
             Patch::remove_node(Some(&"div"), TreePath::new(vec![4]),),
@@ -123,7 +123,7 @@ fn truncate_children_different_attributes() {
         ],
     );
 
-    let patch = diff(&old, &new);
+    let patch = diff(&old, &new).unwrap();
     dbg!(&patch);
 
     assert_eq!(
@@ -146,7 +146,7 @@ fn replace_node2() {
     let old: Node<()> = div(vec![], vec![b(vec![], vec![text("1")]), b(vec![], vec![])]);
     let new = div(vec![], vec![i(vec![], vec![text("1")]), i(vec![], vec![])]);
 
-    let patch = diff(&old, &new);
+    let patch = diff(&old, &new).unwrap();
     dbg!(&patch);
     assert_eq!(
         patch,
@@ -168,7 +168,7 @@ fn remove_nodes1() {
     let new = div(vec![], vec![]); //{ <div> </div> },
 
     assert_eq!(
-        dbg!(diff(&old, &new)),
+        dbg!(diff(&old, &new).unwrap()),
         vec![Patch::clear_children(Some(&"div"), TreePath::new(vec![]),),],
         "Remove all child nodes at and after child sibling index 1",
     );
@@ -195,7 +195,7 @@ fn remove_nodes2() {
     let new: Node<()> = div(vec![], vec![span(vec![], vec![b(vec![], vec![])])]);
 
     assert_eq!(
-        dbg!(diff(&old, &new)),
+        dbg!(diff(&old, &new).unwrap()),
         vec![
             Patch::remove_node(Some(&"i"), TreePath::new(vec![0, 1]),),
             Patch::remove_node(Some(&"strong"), TreePath::new(vec![1]),),
@@ -218,7 +218,7 @@ fn remove_nodes3() {
         vec![b(vec![], vec![i(vec![], vec![])]), i(vec![], vec![])],
     ); //{ <div> <b> <i></i> </b> <i></i> </div>},
     assert_eq!(
-        dbg!(diff(&old, &new)),
+        dbg!(diff(&old, &new).unwrap()),
         vec![
             Patch::remove_node(Some(&"i"), TreePath::new(vec![0, 1]),),
             Patch::replace_node(Some(&"b"), TreePath::new(vec![1]), vec![&i(vec![], vec![])]),
@@ -232,7 +232,7 @@ fn add_attributes() {
     let old: Node<()> = div(vec![], vec![]); //{ <div> </div> },
     let new = div(vec![id("hello")], vec![]); //{ <div id="hello"> </div> },
     assert_eq!(
-        diff(&old, &new),
+        diff(&old, &new).unwrap(),
         vec![Patch::add_attributes(
             &"div",
             TreePath::new(vec![]),
@@ -245,7 +245,7 @@ fn add_attributes() {
     let new = div(vec![id("hello")], vec![]); //{ <div id="hello"> </div> },
 
     assert_eq!(
-        diff(&old, &new),
+        diff(&old, &new).unwrap(),
         vec![Patch::add_attributes(
             &"div",
             TreePath::new(vec![]),
@@ -260,7 +260,7 @@ fn add_style_attributes() {
     let old: Node<()> = div(vec![style!("display": "block")], vec![]);
     let new = div(vec![style!("display": "none")], vec![]);
     assert_eq!(
-        diff(&old, &new),
+        diff(&old, &new).unwrap(),
         vec![Patch::add_attributes(
             &"div",
             TreePath::new(vec![]),
@@ -281,7 +281,7 @@ fn add_style_attributes_1_change() {
         vec![],
     );
     assert_eq!(
-        diff(&old, &new),
+        diff(&old, &new).unwrap(),
         vec![Patch::add_attributes(
             &"div",
             TreePath::new(vec![]),
@@ -307,7 +307,7 @@ fn add_style_attributes_no_changes() {
         vec![styles([("display", "block"), ("position", "absolute")])],
         vec![],
     );
-    assert_eq!(diff(&old, &new), vec![],);
+    assert_eq!(diff(&old, &new).unwrap(), vec![],);
 }
 
 #[test]
@@ -315,7 +315,7 @@ fn remove_style_attributes() {
     let old: Node<()> = div(vec![style!("display": "block")], vec![]);
     let new = div(vec![], vec![]);
     assert_eq!(
-        diff(&old, &new),
+        diff(&old, &new).unwrap(),
         vec![Patch::remove_attributes(
             &"div",
             TreePath::new(vec![]),
@@ -331,7 +331,7 @@ fn remove_events_will_become_replace_node() {
     let old: Node<()> = div(vec![event1.clone()], vec![]);
     let new = div(vec![], vec![]);
     assert_eq!(
-        diff(&old, &new),
+        diff(&old, &new).unwrap(),
         vec![Patch::remove_attributes(
             &"div",
             TreePath::new(vec![]),
@@ -367,7 +367,7 @@ fn text_changed_in_keyed_elements() {
         )],
     );
 
-    let patch = diff(&old, &update1);
+    let patch = diff(&old, &update1).unwrap();
     dbg!(&patch);
     assert_eq!(
         patch,
@@ -401,7 +401,7 @@ fn multiple_style_calls() {
         ],
         vec![],
     );
-    let patches = diff(&old, &new);
+    let patches = diff(&old, &new).unwrap();
     println!("patches: {:#?}", patches);
     assert_eq!(
         patches,
diff --git a/tests/html_right_next_text_siblings.rs b/tests/html_right_next_text_siblings.rs
index f05b112d..c960e31e 100644
--- a/tests/html_right_next_text_siblings.rs
+++ b/tests/html_right_next_text_siblings.rs
@@ -11,7 +11,7 @@ fn comments_next_to_each_other() {
     );
     let new: Node<()> = div(vec![], vec![comment("hello"), comment("world")]);
 
-    let patch = diff(&old, &new);
+    let patch = diff(&old, &new).unwrap();
     println!("patch: {:#?}", patch);
     assert_eq!(
         patch,
diff --git a/tests/html_skip_criteria_test.rs b/tests/html_skip_criteria_test.rs
index 1879152e..b43a3b6f 100644
--- a/tests/html_skip_criteria_test.rs
+++ b/tests/html_skip_criteria_test.rs
@@ -7,7 +7,7 @@ fn must_skip_diff() {
     let old: Node<()> = div([skip_criteria("line1")], [text("old here")]);
     let new: Node<()> = div([skip_criteria("line1")], [text("new here")]);
 
-    let patch = diff(&old, &new);
+    let patch = diff(&old, &new).unwrap();
     dbg!(&patch);
     assert_eq!(patch, vec![]);
 }
@@ -17,7 +17,7 @@ fn must_skip_diff_2() {
     let old: Node<()> = div([skip_criteria(1000)], [text("Regardless of")]);
     let new: Node<()> = div([skip_criteria(1000)], [text("the difference here")]);
 
-    let patch = diff(&old, &new);
+    let patch = diff(&old, &new).unwrap();
     dbg!(&patch);
     assert_eq!(patch, vec![]);
 }
@@ -27,7 +27,7 @@ fn must_diff() {
     let old: Node<()> = div([skip_criteria(1000)], [text("Regardless of")]);
     let new: Node<()> = div([skip_criteria(1001)], [text("the difference here")]);
 
-    let patch = diff(&old, &new);
+    let patch = diff(&old, &new).unwrap();
     dbg!(&patch);
     assert_eq!(
         patch,
diff --git a/tests/html_style_change.rs b/tests/html_style_change.rs
index ae442f5d..edee30b6 100644
--- a/tests/html_style_change.rs
+++ b/tests/html_style_change.rs
@@ -13,7 +13,7 @@ fn style_calcd_changed() {
         vec![],
     );
 
-    let patches: Vec<Patch<&'static str>> = diff(&old, &new);
+    let patches: Vec<Patch<&'static str>> = diff(&old, &new).unwrap();
     let styl = style! {width: format!("calc(50% + {}", px(200))};
     let expected: Vec<Patch<&'static str>> =
         vec![Patch::add_attributes(&"div", TreePath::new([]), [&styl])];
@@ -36,7 +36,7 @@ fn style_calcd_changed_with_event() {
         vec![],
     );
 
-    let patches: Vec<Patch<()>> = diff(&old, &new);
+    let patches: Vec<Patch<()>> = diff(&old, &new).unwrap();
     let styl = style! {width: format!("calc(50% + {}", px(200))};
     let expected: Vec<Patch<()>> = vec![Patch::add_attributes(&"div", TreePath::new([]), [&styl])];
     assert_eq!(expected, patches);
@@ -91,7 +91,7 @@ fn app_editor_width_allocation_bug() {
         ],
     );
 
-    let patches: Vec<Patch<()>> = diff(&old, &new);
+    let patches: Vec<Patch<()>> = diff(&old, &new).unwrap();
     let styl_1 = style! {width: format!("calc(50% + {}", px(200))};
     let styl_2 = style! {width: format!("calc(50% - {}", px(200))};
     let expected: Vec<Patch<()>> = vec![
diff --git a/tests/html_test.rs b/tests/html_test.rs
index c51f286e..7230e2df 100644
--- a/tests/html_test.rs
+++ b/tests/html_test.rs
@@ -113,7 +113,7 @@ fn replace_node() {
     let old: Node<()> = div(vec![], vec![]);
     let new: Node<()> = span(vec![], vec![]);
     assert_eq!(
-        diff(&old, &new),
+        diff(&old, &new).unwrap(),
         vec![Patch::replace_node(
             Some(&"div"),
             TreePath::new(vec![]),
@@ -125,7 +125,7 @@ fn replace_node() {
     let old: Node<()> = div(vec![], vec![b(vec![], vec![])]);
     let new: Node<()> = div(vec![], vec![strong(vec![], vec![])]);
     assert_eq!(
-        diff(&old, &new),
+        diff(&old, &new).unwrap(),
         vec![Patch::replace_node(
             Some(&"b"),
             TreePath::new(vec![0]),
@@ -135,7 +135,7 @@ fn replace_node() {
 
     let old: Node<()> = div(vec![], vec![b(vec![], vec![text("1")]), b(vec![], vec![])]);
     let new: Node<()> = div(vec![], vec![i(vec![], vec![text("1")]), i(vec![], vec![])]);
-    let patch = diff(&old, &new);
+    let patch = diff(&old, &new).unwrap();
 
     dbg!(&patch);
 
@@ -163,7 +163,7 @@ fn add_children() {
         ],
     ); //{ <div> <b></b> <new></new> </div> },
     assert_eq!(
-        dbg!(diff(&old, &new)),
+        dbg!(diff(&old, &new).unwrap()),
         vec![Patch::append_children(
             Some(&"div"),
             TreePath::new(vec![]),
@@ -178,7 +178,7 @@ fn add_attributes() {
     let old: Node<()> = div(vec![], vec![]);
     let new = div(vec![id("hello")], vec![]);
     assert_eq!(
-        diff(&old, &new),
+        diff(&old, &new).unwrap(),
         vec![Patch::add_attributes(
             &"div",
             TreePath::new(vec![]),
@@ -191,7 +191,7 @@ fn add_attributes() {
     let new = div(vec![id("hello")], vec![]);
 
     assert_eq!(
-        diff(&old, &new),
+        diff(&old, &new).unwrap(),
         vec![Patch::add_attributes(
             &"div",
             TreePath::new(vec![]),
@@ -206,7 +206,7 @@ fn remove_attributes() {
     let old: Node<()> = div(vec![id("hey-there")], vec![]);
     let new = div(vec![], vec![]);
     assert_eq!(
-        diff(&old, &new),
+        diff(&old, &new).unwrap(),
         vec![Patch::remove_attributes(
             &"div",
             TreePath::new(vec![]),
@@ -222,7 +222,7 @@ fn change_attribute() {
     let new = div(vec![id("changed")], vec![]);
 
     assert_eq!(
-        diff(&old, &new),
+        diff(&old, &new).unwrap(),
         vec![Patch::add_attributes(
             &"div",
             TreePath::new(vec![]),
@@ -238,7 +238,7 @@ fn replace_text_node() {
     let new = text("New"); //{ New },
 
     assert_eq!(
-        diff(&old, &new),
+        diff(&old, &new).unwrap(),
         vec![Patch::replace_node(
             None,
             TreePath::new(vec![]),
diff --git a/tests/vdom_class_test.rs b/tests/vdom_class_test.rs
index 09df7641..c0a72c7d 100644
--- a/tests/vdom_class_test.rs
+++ b/tests/vdom_class_test.rs
@@ -14,7 +14,7 @@ fn class_changed() {
         vec![leaf("Content of class")],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
 
     dbg!(&diff);
 
@@ -50,7 +50,7 @@ fn parent_of_matching_keyed_are_ignored() {
         ],
     );
 
-    let patches = diff(&old, &new);
+    let patches = diff(&old, &new).unwrap();
 
     assert_eq!(
         patches,
diff --git a/tests/vdom_diff_keyed_test.rs b/tests/vdom_diff_keyed_test.rs
index f869566e..7dba048f 100644
--- a/tests/vdom_diff_keyed_test.rs
+++ b/tests/vdom_diff_keyed_test.rs
@@ -14,7 +14,7 @@ fn keyed_no_changed() {
         vec![element("div", vec![attr("key", "1")], vec![])],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(diff, vec![]);
 }
 
@@ -35,7 +35,7 @@ fn key_1_removed_at_start() {
         vec![element("div", vec![attr("key", "2")], vec![])],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(
         diff,
         vec![Patch::remove_node(Some(&"div"), TreePath::new(vec![0]))]
@@ -59,7 +59,7 @@ fn non_unique_keys_matched_at_old() {
         vec![element("div", vec![attr("key", "2")], vec![])],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(
         diff,
         vec![Patch::remove_node(Some(&"div"), TreePath::new(vec![1]))]
@@ -83,7 +83,7 @@ fn key_2_removed_at_the_end() {
         vec![element("div", vec![attr("key", "1")], vec![])],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(
         diff,
         vec![Patch::remove_node(Some(&"div"), TreePath::new(vec![1]),)]
@@ -111,7 +111,7 @@ fn key_2_removed_at_the_middle() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(
         diff,
         vec![Patch::remove_node(Some(&"div"), TreePath::new(vec![1]))]
@@ -140,7 +140,7 @@ fn there_are_2_exact_same_keys_in_the_old() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
 
     dbg!(&diff);
 
@@ -175,7 +175,7 @@ fn there_are_2_exact_same_keys_in_the_new() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
 
     dbg!(&diff);
 
@@ -215,7 +215,7 @@ fn there_are_2_exact_same_keys_in_both_old_and_new() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
 
     dbg!(&diff);
 
@@ -251,7 +251,7 @@ fn key_2_inserted_at_start() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     dbg!(&diff);
 
     assert_eq!(
@@ -278,7 +278,7 @@ fn keyed_element_not_reused() {
         vec![element("div", vec![attr("key", "2")], vec![])],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     dbg!(&diff);
 
     assert_eq!(
@@ -309,7 +309,7 @@ fn key_2_inserted_at_the_end() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
 
     dbg!(&diff);
 
@@ -349,7 +349,7 @@ fn test_append_at_sub_level() {
         )],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     dbg!(&diff);
     assert_eq!(
         diff,
@@ -385,7 +385,7 @@ fn key_2_inserted_in_the_middle() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
 
     dbg!(&diff);
 
@@ -420,7 +420,7 @@ fn key1_removed_at_start_then_key2_has_additional_attributes() {
         )],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     dbg!(&diff);
     // we add attrubutes at node index 2, and this will become a node index 1
     assert_eq!(
@@ -465,7 +465,7 @@ fn deep_nested_key1_removed_at_start_then_key2_has_additional_attributes() {
         )],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     dbg!(&diff);
     assert_eq!(
         diff,
@@ -510,7 +510,7 @@ fn deep_nested_more_children_key0_and_key1_removed_at_start_then_key2_has_additi
         )],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     dbg!(&diff);
     assert_eq!(
         diff,
@@ -570,7 +570,7 @@ fn deep_nested_keyed_with_non_keyed_children() {
         )],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     dbg!(&diff);
     assert_eq!(
         diff,
@@ -630,7 +630,7 @@ fn text_changed_in_keyed_elements() {
         )],
     );
 
-    let patch = diff(&old, &update1);
+    let patch = diff(&old, &update1).unwrap();
     dbg!(&patch);
 
     assert_eq!(
@@ -686,7 +686,7 @@ fn text_changed_in_mixed_keyed_and_non_keyed_elements() {
         ],
     );
 
-    let patch = diff(&old, &update1);
+    let patch = diff(&old, &update1).unwrap();
     dbg!(&patch);
     assert_eq!(
         patch,
@@ -745,7 +745,7 @@ fn test12() {
         ],
     );
 
-    let patch = diff(&old, &update1);
+    let patch = diff(&old, &update1).unwrap();
     dbg!(&patch);
     assert_eq!(
         patch,
@@ -782,7 +782,7 @@ fn remove_first() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     dbg!(&diff);
     assert_eq!(
         diff,
diff --git a/tests/vdom_diff_mixed.rs b/tests/vdom_diff_mixed.rs
index 526bd53f..4b00346a 100644
--- a/tests/vdom_diff_mixed.rs
+++ b/tests/vdom_diff_mixed.rs
@@ -23,7 +23,7 @@ fn mixed_key_and_no_key_with_no_change() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     dbg!(&diff);
     assert_eq!(diff, vec![]);
 }
@@ -52,7 +52,7 @@ fn mixed_key_and_no_key_with_2_matched() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     dbg!(&diff);
     assert_eq!(
         diff,
@@ -87,7 +87,7 @@ fn mixed_key_and_no_key_with_misordered_2_matched() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     dbg!(&diff);
 
     assert_eq!(
diff --git a/tests/vdom_diff_node_list.rs b/tests/vdom_diff_node_list.rs
index c633e731..78c10db3 100644
--- a/tests/vdom_diff_node_list.rs
+++ b/tests/vdom_diff_node_list.rs
@@ -31,7 +31,7 @@ fn test_node_list() {
 
     println!("old: {:#?}", old);
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(
         diff,
         vec![Patch::remove_node(Some(&"li"), TreePath::new(vec![2]),)],
diff --git a/tests/vdom_diff_skip_and_replace.rs b/tests/vdom_diff_skip_and_replace.rs
index 30ba51c8..a6fa7bfc 100644
--- a/tests/vdom_diff_skip_and_replace.rs
+++ b/tests/vdom_diff_skip_and_replace.rs
@@ -10,7 +10,7 @@ fn force_replace() {
         vec![],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(
         diff,
         vec![Patch::replace_node(
@@ -30,7 +30,7 @@ fn force_skip() {
         vec![],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(diff, vec![],);
 }
 
@@ -43,7 +43,7 @@ fn skip_in_attribute() {
         vec![],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(diff, vec![],);
 }
 
@@ -56,7 +56,7 @@ fn replace_true_in_attribute_must_replace_old_node_regardless() {
         vec![],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(
         diff,
         vec![Patch::replace_node(
@@ -165,7 +165,7 @@ fn replace_and_skip_in_sub_nodes() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(
         diff,
         vec![Patch::replace_node(
diff --git a/tests/vdom_diff_tests.rs b/tests/vdom_diff_tests.rs
index dda156b0..7addcafe 100644
--- a/tests/vdom_diff_tests.rs
+++ b/tests/vdom_diff_tests.rs
@@ -6,7 +6,7 @@ fn test_replace_node() {
     let old: Node<()> = element("div", vec![], vec![]);
     let new = element("span", vec![], vec![]);
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(
         diff,
         vec![Patch::replace_node(
@@ -22,7 +22,7 @@ fn test_replace_text_node() {
     let old: Node<()> = leaf("hello");
     let new = element("span", vec![], vec![]);
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(
         diff,
         vec![Patch::replace_node(None, TreePath::new(vec![]), vec![&new])],
@@ -34,7 +34,7 @@ fn test_replace_node_in_child() {
     let old: Node<()> = element("main", vec![], vec![element("div", vec![], vec![])]);
     let new = element("main", vec![], vec![element("span", vec![], vec![])]);
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(
         diff,
         vec![Patch::replace_node(
@@ -71,7 +71,7 @@ fn test_205() {
         ],
     ); //{ <div> <b> <i></i> </b> <i></i> </div>},
     assert_eq!(
-        dbg!(diff(&old, &new)),
+        dbg!(diff(&old, &new).unwrap()),
         vec![
             Patch::remove_node(Some(&"i"), TreePath::new(vec![0, 1]),),
             Patch::replace_node(
@@ -97,7 +97,7 @@ fn test_no_changed() {
         vec![],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(diff, vec![])
 }
 
@@ -115,7 +115,7 @@ fn test_attribute_order_changed() {
         vec![],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(diff, vec![])
 }
 
@@ -133,7 +133,7 @@ fn test_class_changed() {
         vec![],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(
         diff,
         vec![Patch::add_attributes(
@@ -158,7 +158,7 @@ fn leaf_node_changed() {
         vec![leaf("text2")],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     dbg!(&diff);
     assert_eq!(
         diff,
@@ -180,7 +180,7 @@ fn test_class_will_not_be_merged_on_different_calls() {
         vec![],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_ne!(
         diff,
         vec![Patch::add_attributes(
@@ -205,7 +205,7 @@ fn test_class_removed() {
 
     let new = element("div", vec![attr("id", "some-id")], vec![]);
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(
         diff,
         vec![Patch::remove_attributes(
@@ -236,7 +236,7 @@ fn test_multiple_calls_to_style() {
         vec![],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(
         diff,
         vec![Patch::add_attributes(
@@ -256,7 +256,7 @@ fn inner_html_func_calls() {
 
     let new: Node<()> = element("div", vec![attr("inner_html", "<h1>Hello</h2>")], vec![]);
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(
         diff,
         vec![Patch::add_attributes(
@@ -284,7 +284,7 @@ fn test_append() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(
         diff,
         vec![Patch::append_children(
@@ -313,7 +313,7 @@ fn test_append_more() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(
         diff,
         vec![Patch::append_children(
@@ -353,7 +353,7 @@ fn test_append_at_sub_level() {
         )],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     dbg!(&diff);
     assert_eq!(
         diff,
diff --git a/tests/vdom_fragment_test.rs b/tests/vdom_fragment_test.rs
index 49f399cc..81fc7d6a 100644
--- a/tests/vdom_fragment_test.rs
+++ b/tests/vdom_fragment_test.rs
@@ -27,7 +27,7 @@ fn using_fragments() {
         element("div", vec![attr("key", "9")], vec![leaf("line9")]),
     ]);
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(
         diff,
         vec![Patch::insert_before_node(
diff --git a/tests/vdom_insert_patches.rs b/tests/vdom_insert_patches.rs
index f9923001..b6e546aa 100644
--- a/tests/vdom_insert_patches.rs
+++ b/tests/vdom_insert_patches.rs
@@ -21,7 +21,7 @@ fn insert_on_deep_level_keyed() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
 
     dbg!(&diff);
 
@@ -70,7 +70,7 @@ fn insert_on_deep_multi_level_level_keyed() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
 
     dbg!(&diff);
 
@@ -119,7 +119,7 @@ fn insert_on_deep_multi_level_keyed_non_keyed_keyed() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
 
     dbg!(&diff);
 
@@ -154,7 +154,7 @@ fn insert_on_deep_level_non_keyed_container() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
 
     dbg!(&diff);
 
diff --git a/tests/vdom_massive_keyed.rs b/tests/vdom_massive_keyed.rs
index 836ff102..d097e8d3 100644
--- a/tests/vdom_massive_keyed.rs
+++ b/tests/vdom_massive_keyed.rs
@@ -35,7 +35,7 @@ fn key_inserted_at_start() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     assert_eq!(
         diff,
         vec![Patch::insert_before_node(
@@ -85,7 +85,7 @@ fn key_inserted_at_middle() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     dbg!(&diff);
 
     assert_eq!(
@@ -145,7 +145,7 @@ fn wrapped_elements() {
         )],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     dbg!(&diff);
     assert_eq!(
         diff,
@@ -203,7 +203,7 @@ fn text_changed() {
         )],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     dbg!(&diff);
     assert_eq!(
         diff,
@@ -257,7 +257,7 @@ fn text_changed_non_keyed() {
         )],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     dbg!(&diff);
 
     assert_eq!(
@@ -350,7 +350,7 @@ fn insert_one_line_at_start() {
         )],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     dbg!(&diff);
     assert_eq!(
         diff,
@@ -462,7 +462,7 @@ fn insert_two_lines_at_start() {
         )],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     dbg!(&diff);
 
     assert_eq!(
diff --git a/tests/vdom_rearranged_keyed_nodes.rs b/tests/vdom_rearranged_keyed_nodes.rs
index 0ae0bc4d..24fc70f6 100644
--- a/tests/vdom_rearranged_keyed_nodes.rs
+++ b/tests/vdom_rearranged_keyed_nodes.rs
@@ -22,7 +22,7 @@ fn text_changed_keyed() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
     dbg!(&diff);
 
     assert_eq!(
diff --git a/tests/vdom_replace_node_patches.rs b/tests/vdom_replace_node_patches.rs
index 2800221e..2974188e 100644
--- a/tests/vdom_replace_node_patches.rs
+++ b/tests/vdom_replace_node_patches.rs
@@ -31,7 +31,7 @@ fn test_multiple_replace() {
         )],
     );
 
-    let patches = diff(&old, &update1);
+    let patches = diff(&old, &update1).unwrap();
 
     dbg!(&patches);
 
diff --git a/tests/vdom_swap_rows.rs b/tests/vdom_swap_rows.rs
index 3479cfbb..11df09df 100644
--- a/tests/vdom_swap_rows.rs
+++ b/tests/vdom_swap_rows.rs
@@ -29,7 +29,7 @@ fn swap_999() {
         }),
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
 
     dbg!(&diff);
 
@@ -68,7 +68,7 @@ fn swap_rows_non_keyed() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
 
     dbg!(&diff);
 
@@ -117,7 +117,7 @@ fn move_key_2_to_after_node_index_6() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
 
     dbg!(&diff);
 
@@ -165,7 +165,7 @@ fn move_key_7_to_before_node_index_1() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
 
     dbg!(&diff);
 
@@ -213,7 +213,7 @@ fn swap_rows_keyed() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
 
     dbg!(&diff);
 
@@ -254,7 +254,7 @@ fn swap_rows_keyed_6_items() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
 
     dbg!(&diff);
 
@@ -293,7 +293,7 @@ fn swap_rows_keyed_5_items() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
 
     dbg!(&diff);
 
diff --git a/tests/vdom_test_diff_lis.rs b/tests/vdom_test_diff_lis.rs
index a63aa643..e1c1a2d9 100644
--- a/tests/vdom_test_diff_lis.rs
+++ b/tests/vdom_test_diff_lis.rs
@@ -40,7 +40,7 @@ fn key_lis_1_to_9() {
         ],
     );
 
-    let diff = diff(&old, &new);
+    let diff = diff(&old, &new).unwrap();
 
     dbg!(&diff);