wip: test for id calculation being stable

offline-web-model/src/test.rs

@@ -240,6 +240,76 @@ fn test_root_id_changes_for_any_reference_update() {
     }
 }
 
+/// Tests that Reference IDs are stable regardless of dependency add order
+#[test]
+fn test_reference_ids_stable_regardless_of_dependency_order() {
+    // Create test dependencies
+    let dep_a = Reference::new(
+        Some(String::from("content_a")),
+        String::from("/dep_a"),
+    ).to_arc();
+    
+    let dep_b = Reference::new(
+        Some(String::from("content_b")),
+        String::from("/dep_b"),
+    ).to_arc();
+    
+    let dep_c = Reference::new(
+        Some(String::from("content_c")),
+        String::from("/dep_c"),
+    ).to_arc();
+    
+    let dep_d = Reference::new(
+        Some(String::from("content_d")),
+        String::from("/dep_d"),
+    ).to_arc();
+    
+    // Create base reference
+    let base_ref = Reference::new(
+        Some(String::from("base_content")),
+        String::from("/base"),
+    );
+    
+    // Test multiple different orders of adding the same dependencies
+    let orders = vec![
+        vec![dep_a.clone(), dep_b.clone(), dep_c.clone(), dep_d.clone()],  // alphabetical
+        vec![dep_d.clone(), dep_c.clone(), dep_b.clone(), dep_a.clone()],  // reverse alphabetical
+        vec![dep_b.clone(), dep_d.clone(), dep_a.clone(), dep_c.clone()],  // random order 1
+        vec![dep_c.clone(), dep_a.clone(), dep_d.clone(), dep_b.clone()],  // random order 2
+        vec![dep_d.clone(), dep_a.clone(), dep_b.clone(), dep_c.clone()],  // random order 3
+    ];
+    
+    let mut all_ids = Vec::new();
+    
+    for (i, order) in orders.iter().enumerate() {
+        let mut test_ref = base_ref.clone();
+        
+        // Add dependencies in this specific order
+        for dep in order {
+            test_ref = test_ref.add_dep(dep.clone());
+        }
+        
+        all_ids.push(test_ref.id.clone());
+        
+        // Verify that dependencies are always sorted lexicographically regardless of add order
+        for j in 0..test_ref.dependents.len() - 1 {
+            let current = &test_ref.dependents[j];
+            let next = &test_ref.dependents[j + 1];
+            
+            assert!(current.name < next.name, 
+                "Dependencies should be lexicographically ordered. Order {}: Found '{}' before '{}'", 
+                i, current.name, next.name);
+        }
+    }
+    
+    // Verify all IDs are identical
+    let first_id = &all_ids[0];
+    for (i, id) in all_ids.iter().enumerate() {
+        assert_eq!(id, first_id, 
+            "Reference ID should be stable regardless of dependency add order. Order {} produced different ID", i);
+    }
+}
+
 /// Tests that dependencies of a Reference are always lexicographically ordered by name
 #[test]
 fn test_dependencies_lexicographically_ordered() {