@feltdb/core 0.12.0 → 0.12.2

package/dist/create/server-source/crates/feltdb/tests/generalized_version_control_substrate_completion.rs

@@ -201,11 +201,17 @@ fn gc_root_discovery_and_unreachable_collection() {
     let store = StateStore::new_volatile();
     let (_a, _b, _c, _d) = setup_gc_graph(&store);
     let report = collect(&store);
-    assert_eq!(report.roots.len(), 0);
-    assert_eq!(report.reachable_revisions.len(), 0);
-    assert_eq!(report.reachable_objects.len(), 0);
-    assert_eq!(report.collected_revisions.len(), 4);
-    assert_eq!(report.collected_objects.len(), 4);
+    // Roots are refs, each resource's latest revisions, and anything younger
+    // than the grace period (adrs/state-ref-authority-and-safe-reclamation.md,
+    // option A). Before that decision this test asserted that a store with no
+    // refs collected all four revisions, which is the history loss the
+    // decision removes. Collection of a stale fork is covered, with an explicit
+    // clock, by `state_model::tests::gc_keeps_latest_revisions_refs_and_all_their_ancestors`.
+    assert_eq!(report.roots.len(), 0, "no refs");
+    assert_eq!(report.reachable_revisions.len(), 4);
+    assert_eq!(report.reachable_objects.len(), 4);
+    assert!(report.collected_revisions.is_empty());
+    assert!(report.collected_objects.is_empty());
 }
 
 #[test]
@@ -222,14 +228,23 @@ fn gc_parent_and_content_traversal_preserves_shared_history() {
     let keep_all = collect(&store);
     assert!(keep_all.collected_revisions.is_empty());
 
+    // Shared history is reached through both refs.
+    for ancestor in [&a, &b] {
+        assert!(keep_all.reachable_revisions.contains(ancestor));
+    }
+
+    // Deleting d's ref no longer makes d collectable: d ties c at the highest
+    // sequence, so it is one of the resource's latest revisions, and it is
+    // younger than the grace period. (Before option A this asserted that d was
+    // collected.) Its ancestors are still reached, and nothing is lost.
     store.delete_ref("refs", "d", Some(1)).unwrap();
     let after_delete = collect(&store);
-    assert!(after_delete.collected_revisions.contains(&d));
-    assert!(!after_delete.collected_revisions.contains(&b));
-    assert!(!after_delete.collected_revisions.contains(&c));
-    assert!(!after_delete.collected_revisions.contains(&a));
-    assert_eq!(after_delete.collected_revisions.len(), 1);
-    assert_eq!(after_delete.collected_objects.len(), 1);
+    assert!(after_delete.collected_revisions.is_empty());
+    assert!(after_delete.collected_objects.is_empty());
+    for kept in [&a, &b, &c, &d] {
+        assert!(store.exists(kept));
+        assert!(after_delete.reachable_revisions.contains(kept));
+    }
 }
 
 #[test]
@@ -275,7 +290,10 @@ fn substrate_is_domain_neutral_for_refs_materialization_and_gc() {
             .delete_ref("heads", &reference.name, Some(reference.version))
             .unwrap();
     }
+    // Without their refs each resource's only revision is still its latest, so
+    // nothing is collected. (Before option A this asserted all three were.)
     let collected = collect(&store);
-    assert_eq!(collected.collected_revisions.len(), 3);
-    assert_eq!(collected.collected_objects.len(), 3);
+    assert!(collected.collected_revisions.is_empty());
+    assert!(collected.collected_objects.is_empty());
+    assert_eq!(collected.reachable_revisions.len(), 3);
 }