wip: more tests!

packages/core/tests/passthru.rs

@@ -0,0 +1,101 @@
+use dioxus::core::Mutation::*;
+use dioxus::prelude::*;
+use dioxus_core::ElementId;
+
+/// Should push the text node onto the stack and modify it
+#[test]
+fn nested_passthru_creates() {
+    fn app(cx: Scope) -> Element {
+        cx.render(rsx! {
+            Child {
+                Child {
+                    Child {
+                        div {
+                            "hi"
+                        }
+                    }
+                }
+            }
+        })
+    }
+
+    #[inline_props]
+    fn Child<'a>(cx: Scope<'a>, children: Element<'a>) -> Element {
+        cx.render(rsx! { children })
+    }
+
+    let mut dom = VirtualDom::new(app);
+    let edits = dom.rebuild().santize();
+
+    assert_eq!(
+        edits.edits,
+        [
+            LoadTemplate { name: "template", index: 0 },
+            AppendChildren { m: 1 },
+        ]
+    )
+}
+
+/// Should load all the templates and append them
+#[test]
+fn nested_passthru_creates_add() {
+    fn app(cx: Scope) -> Element {
+        cx.render(rsx! {
+            child_comp {
+                "1"
+                child_comp {
+                    "2"
+                    child_comp {
+                        "3"
+                        div {
+                            "hi"
+                        }
+                    }
+                }
+            }
+        })
+    }
+
+    #[inline_props]
+    fn child_comp<'a>(cx: Scope, children: Element<'a>) -> Element {
+        cx.render(rsx! { children })
+    }
+
+    let mut dom = VirtualDom::new(app);
+
+    assert_eq!(
+        dom.rebuild().santize().edits,
+        [
+            LoadTemplate { name: "template", index: 0 },
+            LoadTemplate { name: "template", index: 0 },
+            LoadTemplate { name: "template", index: 0 },
+            LoadTemplate { name: "template", index: 1 },
+            AppendChildren { m: 4 },
+        ]
+    );
+}
+
+#[test]
+fn dynamic_node_as_root() {
+    fn app(cx: Scope) -> Element {
+        let a = 123;
+        let b = 456;
+        cx.render(rsx! { "{a}" "{b}" })
+    }
+
+    let mut dom = VirtualDom::new(app);
+    let edits = dom.rebuild().santize();
+
+    // Since the roots were all dynamic, they should not cause any template muations
+    assert_eq!(edits.template_mutations, []);
+
+    // The root node is text, so we just create it on the spot
+    assert_eq!(
+        edits.edits,
+        [
+            CreateTextNode { value: "123", id: ElementId(1) },
+            CreateTextNode { value: "456", id: ElementId(2) },
+            AppendChildren { m: 2 }
+        ]
+    )
+}

packages/core/tests/safety.rs

@@ -1,15 +1,21 @@
+//! Tests related to safety of the library.
+
 use dioxus::prelude::*;
 use dioxus_core::SuspenseContext;
 
-/// Ensure no issues with not building the virtualdom before
+/// Ensure no issues with not calling rebuild
 #[test]
 fn root_node_isnt_null() {
     let dom = VirtualDom::new(|cx| render!("Hello world!"));
 
     let scope = dom.base_scope();
 
-    // The root should be a valid pointer
-    assert_ne!(scope.root_node() as *const _, std::ptr::null_mut());
+    // We haven't built the tree, so trying to get out the root node should fail
+    assert!(scope.try_root_node().is_none());
+
+    // There should be no way to gain an invalid pointer
+    assert!(scope.current_frame().node.get().is_null());
+    assert!(scope.previous_frame().node.get().is_null());
 
     // The height should be 0
     assert_eq!(scope.height(), 0);
@@ -18,13 +24,3 @@ fn root_node_isnt_null() {
     // todo: there should also be a default error boundary
     assert!(scope.has_context::<SuspenseContext>().is_some());
 }
-
-#[test]
-fn elements() {
-    let mut dom = VirtualDom::new(|cx| {
-        //
-        cx.render(rsx!( div { "Hello world!" } ))
-    });
-
-    let muts = dom.rebuild();
-}