Add a new test for patch communicativity, which is currently failing:

server/tests/snapshot_reconciler.rs

@@ -0,0 +1,112 @@
+mod test_util;
+
+use std::collections::HashMap;
+
+use pretty_assertions::assert_eq;
+use rbx_dom_weak::{RbxTree, RbxInstanceProperties};
+
+use librojo::{
+    snapshot_reconciler::{RbxSnapshotInstance, reconcile_subtree},
+};
+
+use test_util::tree::trees_equal;
+
+#[test]
+fn patch_communicativity() {
+    let base_tree = RbxTree::new(RbxInstanceProperties {
+        name: "DataModel".into(),
+        class_name: "DataModel".into(),
+        properties: HashMap::new(),
+    });
+
+    let patch_a = RbxSnapshotInstance {
+        name: "DataModel".into(),
+        class_name: "DataModel".into(),
+        children: vec![
+            RbxSnapshotInstance {
+                name: "Child-A".into(),
+                class_name: "Folder".into(),
+                ..Default::default()
+            },
+        ],
+        ..Default::default()
+    };
+
+    let patch_b = RbxSnapshotInstance {
+        name: "DataModel".into(),
+        class_name: "DataModel".into(),
+        children: vec![
+            RbxSnapshotInstance {
+                name: "Child-B".into(),
+                class_name: "Folder".into(),
+                ..Default::default()
+            },
+        ],
+        ..Default::default()
+    };
+
+    let patch_combined = RbxSnapshotInstance {
+        name: "DataModel".into(),
+        class_name: "DataModel".into(),
+        children: vec![
+            RbxSnapshotInstance {
+                name: "Child-A".into(),
+                class_name: "Folder".into(),
+                ..Default::default()
+            },
+            RbxSnapshotInstance {
+                name: "Child-B".into(),
+                class_name: "Folder".into(),
+                ..Default::default()
+            },
+        ],
+        ..Default::default()
+    };
+
+    let root_id = base_tree.get_root_id();
+
+    let mut tree_a = base_tree.clone();
+
+    reconcile_subtree(
+        &mut tree_a,
+        root_id,
+        &patch_a,
+        &mut Default::default(),
+        &mut Default::default(),
+        &mut Default::default(),
+    );
+
+    reconcile_subtree(
+        &mut tree_a,
+        root_id,
+        &patch_combined,
+        &mut Default::default(),
+        &mut Default::default(),
+        &mut Default::default(),
+    );
+
+    let mut tree_b = base_tree.clone();
+
+    reconcile_subtree(
+        &mut tree_b,
+        root_id,
+        &patch_b,
+        &mut Default::default(),
+        &mut Default::default(),
+        &mut Default::default(),
+    );
+
+    reconcile_subtree(
+        &mut tree_b,
+        root_id,
+        &patch_combined,
+        &mut Default::default(),
+        &mut Default::default(),
+        &mut Default::default(),
+    );
+
+    match trees_equal(&tree_a, &tree_b) {
+        Ok(_) => {}
+        Err(e) => panic!("{}", e),
+    }
+}

server/tests/test_util/tree.rs

@@ -53,7 +53,7 @@ pub fn tree_step(step: &str, live_session: &LiveSession, source_path: &Path) {
     };
 
     match read_tree_by_name(source_path, step) {
-        Some(expected) => match trees_equal(&expected, &tree_with_metadata) {
+        Some(expected) => match trees_and_metadata_equal(&expected, &tree_with_metadata) {
             Ok(_) => {}
             Err(e) => {
                 error!("Trees at step '{}' were not equal.\n{}", step, e);
@@ -148,7 +148,7 @@ fn write_tree_by_name(path: &Path, identifier: &str, tree: &TreeWithMetadata) {
 }
 
 #[derive(Debug)]
-struct TreeMismatch {
+pub struct TreeMismatch {
     pub path: Cow<'static, str>,
     pub detail: Cow<'static, str>,
 }
@@ -161,7 +161,7 @@ impl TreeMismatch {
         }
     }
 
-    pub fn add_parent(mut self, name: &str) -> TreeMismatch {
+    fn add_parent(mut self, name: &str) -> TreeMismatch {
         self.path.to_mut().insert(0, '.');
         self.path.to_mut().insert_str(0, name);
 
@@ -179,7 +179,24 @@ impl fmt::Display for TreeMismatch {
     }
 }
 
-fn trees_equal(
+pub fn trees_equal(
+    left_tree: &RbxTree,
+    right_tree: &RbxTree,
+) -> Result<(), TreeMismatch> {
+    let left = TreeWithMetadata {
+        tree: Cow::Borrowed(left_tree),
+        metadata: Cow::Owned(HashMap::new()),
+    };
+
+    let right = TreeWithMetadata {
+        tree: Cow::Borrowed(right_tree),
+        metadata: Cow::Owned(HashMap::new()),
+    };
+
+    trees_and_metadata_equal(&left, &right)
+}
+
+fn trees_and_metadata_equal(
     left_tree: &TreeWithMetadata,
     right_tree: &TreeWithMetadata,
 ) -> Result<(), TreeMismatch> {