tests write through document::testing helpers

1 files changed, 56 insertions, 61 deletions

diff --git a/src/remake/delta.rs b/src/remake/delta.rs
index aebd048..21c07b7 100644
--- a/src/remake/delta.rs
+++ b/src/remake/delta.rs
@@ -251,6 +251,7 @@ pub(crate) fn changed_paths(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::document::testing::{change, try_change};
     use automerge::{ObjType, ROOT, ReadDoc, ScalarValue, transaction::Transactable};
     use serde_json::json;
 
@@ -265,8 +266,8 @@ mod tests {
         const KEYS: [&str; 3] = ["a", "b", "c"];
         let depth = rng.between(1, 3);
         let path: Vec<String> = (0..depth).map(|_| rng.pick(&KEYS).to_string()).collect();
-        let result = if rng.chance(0.2) {
-            store::delete_path(doc, &path, false)
+        let _ = if rng.chance(0.2) {
+            try_change(doc, |doc| store::delete_path(doc, &path, false))
         } else {
             let value = match rng.below(4) {
                 0 => json!(rng.below(100)),
@@ -278,16 +279,8 @@ mod tests {
                     serde_json::Value::Object(map)
                 }
             };
-            store::write_path(doc, &path, &value)
+            try_change(doc, |doc| store::write_path(doc, &path, &value))
         };
-        match result {
-            Ok(()) => {
-                doc.commit_with(automerge::transaction::CommitOptions::default().with_time(0));
-            }
-            Err(_) => {
-                doc.rollback();
-            }
-        }
     }
 
     /// Compaction's promise: a snapshot of the base plus everything replayed since gives
@@ -302,8 +295,9 @@ mod tests {
             }
             let base = old.get_heads();
             let mut new = AutoCommit::new().with_actor(actor(100));
-            store::materialize_into(&old, &mut new, &|_| false).unwrap();
-            new.commit();
+            change(&mut new, |new| {
+                store::materialize_into(&old, new, &|_| false).unwrap()
+            });
 
             let mut nodes: Vec<AutoCommit> = (1..=rng.between(1, 3))
                 .map(|i| old.fork().with_actor(actor(i as u8)))
@@ -395,19 +389,21 @@ mod tests {
     #[test]
     fn minimal_paths() {
         let mut doc = AutoCommit::new();
-        doc.put(ROOT, "untouched", 1_i64).unwrap();
+        change(&mut doc, |doc| doc.put(ROOT, "untouched", 1_i64).unwrap());
         let before = doc.get_heads();
 
-        let m = doc.put_object(ROOT, "m", ObjType::Map).unwrap();
-        doc.put(&m, "a", 1_i64).unwrap();
-        doc.put(ROOT, "x", 1_i64).unwrap();
-        doc.put(ROOT, "c", ScalarValue::counter(0)).unwrap();
-        doc.commit();
+        change(&mut doc, |doc| {
+            let m = doc.put_object(ROOT, "m", ObjType::Map).unwrap();
+            doc.put(&m, "a", 1_i64).unwrap();
+            doc.put(ROOT, "x", 1_i64).unwrap();
+            doc.put(ROOT, "c", ScalarValue::counter(0)).unwrap();
+        });
         let middle = doc.get_heads();
-        doc.increment(ROOT, "c", 2).unwrap();
-        let list = doc.put_object(ROOT, "l", ObjType::List).unwrap();
-        doc.insert(&list, 0, "e").unwrap();
-        doc.commit();
+        change(&mut doc, |doc| {
+            doc.increment(ROOT, "c", 2).unwrap();
+            let list = doc.put_object(ROOT, "l", ObjType::List).unwrap();
+            doc.insert(&list, 0, "e").unwrap();
+        });
         let after = doc.get_heads();
 
         let all = changed_paths(&mut doc, &before, &after);
@@ -429,26 +425,30 @@ mod tests {
     fn replays_state_per_key() {
         // Base shared by the old document and the snapshot.
         let mut old = AutoCommit::new();
-        let m = old.put_object(ROOT, "m", ObjType::Map).unwrap();
-        old.put(&m, "keep", "base").unwrap();
-        old.put(&m, "change", "base").unwrap();
-        old.put(ROOT, "gone", true).unwrap();
-        old.commit();
+        let m = change(&mut old, |old| {
+            let m = old.put_object(ROOT, "m", ObjType::Map).unwrap();
+            old.put(&m, "keep", "base").unwrap();
+            old.put(&m, "change", "base").unwrap();
+            old.put(ROOT, "gone", true).unwrap();
+            m
+        });
         let base = old.get_heads();
 
         let mut new = AutoCommit::new();
-        store::materialize_into(&old, &mut new, &|_| false).unwrap();
-        // Something the new epoch already holds that the delta must not clobber.
-        let Some((_, m_new)) = new.get(ROOT, "m").unwrap() else {
-            panic!("m missing");
-        };
-        new.put(&m_new, "keep", "new epoch").unwrap();
-        new.commit();
+        change(&mut new, |new| {
+            store::materialize_into(&old, new, &|_| false).unwrap();
+            // Something the new epoch already holds that the delta must not clobber.
+            let Some((_, m_new)) = new.get(ROOT, "m").unwrap() else {
+                panic!("m missing");
+            };
+            new.put(&m_new, "keep", "new epoch").unwrap();
+        });
 
         // The delta: one key changed, one key deleted.
-        old.put(&m, "change", "delta").unwrap();
-        old.delete(ROOT, "gone").unwrap();
-        old.commit();
+        change(&mut old, |old| {
+            old.put(&m, "change", "delta").unwrap();
+            old.delete(ROOT, "gone").unwrap();
+        });
         let after = old.get_heads();
 
         let stats = replay(&mut old, &base, &after, &mut new, &Translator::default());
@@ -465,8 +465,7 @@ mod tests {
         let other = ActorId::from(&b"other-actor"[..]);
 
         let mut doc = AutoCommit::new().with_actor(own.clone());
-        doc.put(ROOT, "base", 1_i64).unwrap();
-        doc.commit();
+        change(&mut doc, |doc| doc.put(ROOT, "base", 1_i64).unwrap());
         let base = doc.get_heads();
 
         // The snapshot contains the base only.
@@ -474,14 +473,14 @@ mod tests {
 
         // A foreign change after the base (replayed by its own node) ...
         let mut foreign = doc.fork().with_actor(other);
-        foreign.put(ROOT, "theirs", 1_i64).unwrap();
-        foreign.commit();
+        change(&mut foreign, |foreign| {
+            foreign.put(ROOT, "theirs", 1_i64).unwrap()
+        });
         doc.merge(&mut foreign).unwrap();
         let with_foreign = doc.get_heads();
 
         // ... and one of ours.
-        doc.put(ROOT, "mine", 1_i64).unwrap();
-        doc.commit();
+        change(&mut doc, |doc| doc.put(ROOT, "mine", 1_i64).unwrap());
         let after = doc.get_heads();
 
         let missing = missing_from_snapshot(&mut doc, &clock, std::slice::from_ref(&own));
@@ -505,28 +504,24 @@ mod tests {
     #[test]
     fn protocol_metadata_is_never_replayed() {
         let mut old = AutoCommit::new();
-        old.put(ROOT, "x", 1_i64).unwrap();
-        old.commit();
+        change(&mut old, |old| old.put(ROOT, "x", 1_i64).unwrap());
         let base = old.get_heads();
 
         let mut new = AutoCommit::new();
-        store::write_path(
-            &mut new,
-            &meta::path(&[EPOCHS, "1"]),
-            &json!({ "generation": 1 }),
-        )
-        .unwrap();
-        new.commit();
+        change(&mut new, |new| {
+            store::write_path(
+                new,
+                &meta::path(&[EPOCHS, "1"]),
+                &json!({ "generation": 1 }),
+            )
+            .unwrap()
+        });
 
         // The old epoch replaces `_continuum` wholesale and writes a remake record.
-        store::write_path(
-            &mut old,
-            &meta::path(&[]),
-            &json!({ "forgotten": { "pk": 1 } }),
-        )
-        .unwrap();
-        store::write_path(&mut old, &meta::path(&[REMAKES, "c"]), &json!({ "x": 1 })).unwrap();
-        old.commit();
+        change(&mut old, |old| {
+            store::write_path(old, &meta::path(&[]), &json!({ "forgotten": { "pk": 1 } })).unwrap();
+            store::write_path(old, &meta::path(&[REMAKES, "c"]), &json!({ "x": 1 })).unwrap();
+        });
         let after = old.get_heads();
 
         replay(&mut old, &base, &after, &mut new, &Translator::default());