Commit 550d71c9d8ee053ba3bf16b0269e6bdac3352136 | snowbound

author	clover caruso <git@paperclover.net> 2026-10-10 20:23:52-07:00
committer	clover caruso <git@paperclover.net> 2026-10-10 22:56:05-07:00
log	550d71c9d8ee053ba3bf16b0269e6bdac3352136
tree	00fe54abd2b48de1005ee20753f5d3325f078998
parent	3bc26d2f339e409b94776447c6d0cd661d5da6ff
signature	Signed by SSH key SHA256:52mNGHRsVFBDED9IAX5pe+LRWUefqTbxEReunq21QvU (~clover)

test: retain attribution invariants across writer comparisons

Use the same final edit FILETIME for equivalent page lowerings, keeping revision metadata equality exact. Check timestamp and author separately at writer checkpoints and outline/tree edits while preserving untouched fields, identities and historical bytes.

Assisted-by: gpt-6.1-sol

4 files changed, 92 insertions(+), 20 deletions(-)

crates
- onestore
  - tests
    outline.rs
    page_writer.rs
    tree.rs
    writer.rs

crates/onestore/tests/outline.rs+32-4

 @@ -9,6 +9,8 @@ use std::collections::BTreeSet;
 mod current;
 #[path = "support/disk.rs"]
 mod disk;
+#[path = "support/metadata.rs"]
+mod metadata;
 #[path = "support/ops.rs"]
 mod ops;
 #[path = "support/sweep.rs"]
 @@ -67,6 +69,7 @@ fn geometry_and_expansion_preserve_unrelated_properties_objects_and_history() {
     for (name, sid, object, edit) in cases(&document) {
         let restored = serde_json::from_value(serde_json::to_value(edit).unwrap()).unwrap();
         assert_eq!(edit, restored);
+        let started = ops::now();
         let prepared = ops::page_op(
             SOURCE,
             sid,
 @@ -76,6 +79,7 @@ fn geometry_and_expansion_preserve_unrelated_properties_objects_and_history() {
             },
         )
         .unwrap();
+        let finished = ops::now();
         let after_store = Store::parse(prepared.as_bytes()).unwrap();
         assert!(after_store.checksum_mismatches.is_empty());
         let after_index = RevisionIndex::parse(&after_store).unwrap();
 @@ -100,15 +104,33 @@ fn geometry_and_expansion_preserve_unrelated_properties_objects_and_history() {
                     .then_some(*parent)
             }));
         }
-        assert_eq!(
+        let old_raw = index.resolve_active(sid).unwrap();
-            before.nodes.keys().collect::<Vec<_>>(),
+        let new_raw = after_index.resolve_active(sid).unwrap();
-            after.nodes.keys().collect::<Vec<_>>()
+        let at = metadata::check(&old_raw, &new_raw, "Author");
+        assert!((started..=finished).contains(&at));
+        let author = metadata::author(&new_raw.objects[&new_raw.roots[&4]]);
+        assert!(
+            after
+                .nodes
+                .keys()
+                .all(|id| before.nodes.contains_key(id) || *id == after.roots[&4] || *id == author)
         );
         for (id, node) in &before.nodes {
+            if Some(id) == before.roots.get(&4) {
+                continue;
+            }
             let mut expected = serde_json::to_value(node).unwrap();
             let actual = serde_json::to_value(&after.nodes[id]).unwrap();
             if changed.contains(id) {
                 expected["modified"] = actual["modified"].clone();
+                if matches!(node.kind, Kind::Paragraph { .. }) {
+                    assert_eq!(after.nodes[id].latest_author, Some(author));
+                    assert_eq!(
+                        after.nodes[id].modified.map(u64::from),
+                        Some(at / 10_000_000 - 11_960_006_400)
+                    );
+                    expected["latest_author"] = actual["latest_author"].clone();
+                }
             }
             if *id == object {
                 match edit {
 @@ -344,6 +366,7 @@ fn outline_movement_updates_both_automatic_title_fields_without_changing_content
         (144.0, 36.0, "First"),
         (0.0, 144.0, "First"),
     ] {
+        let started = ops::now();
         let edit = ops::page_op(
             &source,
             sid,
 @@ -353,12 +376,17 @@ fn outline_movement_updates_both_automatic_title_fields_without_changing_content
             },
         )
         .unwrap();
+        let finished = ops::now();
         let saved = Store::parse(edit.as_bytes()).unwrap();
         let saved_index = RevisionIndex::parse(&saved).unwrap();
         saved_index.validate_current().unwrap();
         let saved_document = Document::parse(&saved_index).unwrap();
         let saved_space = &saved_document.spaces[&sid];
         let after = &saved_space.revisions[&saved_space.contexts[&ExGuid::default()]];
+        let old_raw = index.resolve_active(sid).unwrap();
+        let new_raw = saved_index.resolve_active(sid).unwrap();
+        let at = metadata::check(&old_raw, &new_raw, "Author");
+        assert!((started..=finished).contains(&at));
         let metadata = before.roots[&2];
         assert!(
             matches!(&after.nodes[&metadata].kind, Kind::Metadata { title: Some(title), .. } if title == expected)
 @@ -371,7 +399,7 @@ fn outline_movement_updates_both_automatic_title_fields_without_changing_content
             after.nodes.keys().collect::<Vec<_>>()
         );
         for (oid, node) in &before.nodes {
-            if ![page, metadata, insertion].contains(oid) {
+            if ![page, metadata, insertion, before.roots[&4]].contains(oid) {
                 assert_eq!(
                     serde_json::to_value(node).unwrap(),
                     serde_json::to_value(&after.nodes[oid]).unwrap()

crates/onestore/tests/page_writer.rs+32-5

 @@ -1,6 +1,8 @@
 //! A page edit lowered whole (`op::lower_page`) must publish the same graph its ops applied
 //! one by one publish, in one transaction, and must round-trip the model it was given.
+#[path = "support/metadata.rs"]
+mod metadata;
 #[path = "support/ops.rs"]
 mod ops;
 @@ -164,7 +166,7 @@ fn same_element(revision_a: &Revision<'_>, revision_b: &Revision<'_>, id: ExGuid
 }
 /// Every active revision the ops produced one by one is reproduced by the page lowered whole,
-/// ignoring writer-allocated immutable styles and author records. Modification times are
+/// ignoring writer-allocated immutable styles and author records. Paragraph modification times are
 /// not compared: a reorder can be attributed to either sibling, and the model cannot say which.
 fn equivalent(reference: &[u8], written: &[u8]) {
     let store_a = Store::parse(reference).unwrap();
 @@ -201,11 +203,29 @@ fn equivalent(reference: &[u8], written: &[u8]) {
     }
 }
-/// Lowers the page the ops produced whole and checks both contracts.
+/// Both lowerings use the last op's FILETIME so revision metadata compares exactly.
 fn oracle(source: &[u8], space: ExGuid, reference: &[u8]) -> Vec<u8> {
     let after = page_in(reference, space);
-    let prepared = ops::saved(source, space, &after).unwrap();
+    let store = Store::parse(reference).unwrap();
-    let written = prepared.as_slice().to_vec();
+    let index = RevisionIndex::parse(&store).unwrap();
+    let revision = index.resolve_active(space).unwrap();
+    let source_store = Store::parse(source).unwrap();
+    let source_index = RevisionIndex::parse(&source_store).unwrap();
+    let original = source_index.resolve_active(space).unwrap();
+    let at = metadata::check(&original, &revision, AUTHOR);
+    let arena = onestore::Arena::default();
+    let mut section = onestore::Section::open(&arena, source.to_vec()).unwrap();
+    let before = section.page(space).unwrap();
+    let ops = onestore::op::lower_page(&before, &after)
+        .unwrap()
+        .into_iter()
+        .map(|op| onestore::op::Op::Page { space, op })
+        .collect();
+    section
+        .apply(AUTHOR, &onestore::op::Edit { at, ops })
+        .unwrap();
+    section.seal().unwrap().unwrap();
+    let written = section.image();
     assert_eq!(page_in(&written, space), after, "model round trip");
     equivalent(reference, &written);
     let transactions = |bytes: &[u8]| Store::parse(bytes).unwrap().header.transaction_count;
 @@ -583,7 +603,9 @@ fn model_edits_round_trip_and_leave_other_objects_untouched() {
     );
     outline.paragraphs.push(paragraph);
     after.objects.push(PageObject::Outline(outline));
+    let started = ops::now();
     let written = ops::saved(TREES, space, &after).unwrap();
+    let finished = ops::now();
     let stored = page_in(written.as_slice(), space);
     let normalize = |page: &Page| -> Vec<(ExGuid, Vec<(ExGuid, String)>)> {
         body(page)
 @@ -616,6 +638,8 @@ fn model_edits_round_trip_and_leave_other_objects_untouched() {
     let store = Store::parse(written.as_slice()).unwrap();
     let index = RevisionIndex::parse(&store).unwrap();
     let raw_after = index.resolve_active(space).unwrap();
+    let at = metadata::check(&raw_before, &raw_after, AUTHOR);
+    assert!((started..=finished).contains(&at));
     let touched: BTreeSet<ExGuid> = body(&after)
         .iter()
         .flat_map(|o| {
 @@ -629,7 +653,10 @@ fn model_edits_round_trip_and_leave_other_objects_untouched() {
         .collect();
     let mut untouched = 0;
     for (id, object) in &raw_before.objects {
-        if touched.contains(id) || matches!(object.jcid, 0x12004d | 0x120001) {
+        if touched.contains(id)
+            || Some(id) == raw_before.roots.get(&4)
+            || matches!(object.jcid, 0x12004d | 0x120001)
+        {
             continue;
         }
         let after = &raw_after.objects[id];

crates/onestore/tests/tree.rs+17-9

 @@ -9,6 +9,8 @@ use std::collections::{BTreeMap, BTreeSet};
 mod current;
 #[path = "support/disk.rs"]
 mod disk;
+#[path = "support/metadata.rs"]
+mod metadata;
 #[path = "support/ops.rs"]
 mod ops;
 #[path = "support/sweep.rs"]
 @@ -191,8 +193,10 @@ fn native_subtree_controls_match_with_preserved_fields_and_history() {
                 .into_iter()
                 .map(|op| Op::Page { space: sid, op })
                 .collect();
+            let started = ops::now();
             let prepared = ops::apply(source, "Tree author", edit.clone())
                 .unwrap_or_else(|error| panic!("{name}: {error}"));
+            let finished = ops::now();
             let after_store = Store::parse(prepared.as_bytes()).unwrap();
             assert!(after_store.checksum_mismatches.is_empty());
             let after_index = RevisionIndex::parse(&after_store).unwrap();
 @@ -200,6 +204,11 @@ fn native_subtree_controls_match_with_preserved_fields_and_history() {
             let after_document = Document::parse(&after_index).unwrap();
             let space = &after_document.spaces[&sid];
             let after = &space.revisions[&space.contexts[&ExGuid::default()]];
+            let old_raw = index.resolve_active(sid).unwrap();
+            let new_raw = after_index.resolve_active(sid).unwrap();
+            let at = metadata::check(&old_raw, &new_raw, "Tree author");
+            assert!((started..=finished).contains(&at));
+            let author = metadata::author(&new_raw.objects[&new_raw.roots[&4]]);
             let space = &native_document.spaces[&sid];
             let reference = &space.revisions[&space.contexts[&ExGuid::default()]];
             let old_ids = active(before, page);
 @@ -284,15 +293,14 @@ fn native_subtree_controls_match_with_preserved_fields_and_history() {
                     {
                         assert!(node.modified >= old.modified);
                         expected["modified"] = actual["modified"].clone();
-                    }
+                        if matches!(node.kind, Kind::Paragraph { .. }) {
-                    if *id == object
+                            assert_eq!(node.latest_author, Some(author));
-                        && !name.starts_with("Delete")
+                            assert_eq!(
-                        && matches!(node.kind, Kind::Paragraph { .. })
+                                node.modified.map(u64::from),
-                    {
+                                Some(at / 10_000_000 - 11_960_006_400)
-                        expected["latest_author"] = actual["latest_author"].clone();
+                            );
-                        assert!(
+                            expected["latest_author"] = actual["latest_author"].clone();
-                            matches!(&after.nodes[&node.latest_author.unwrap()].kind,Kind::Author{name:Some(name)} if name=="Tree author")
+                        }
-                        );
                     }
                     for value in [&mut expected, &mut actual] {
                         value["extra"][0]

crates/onestore/tests/writer.rs+11-2

...	@@ -1,3 +1,5 @@	...	@@ -1,3 +1,5 @@
		1	#[path = "support/metadata.rs"]
		2	mod metadata;
1	#[path = "support/ops.rs"]	3	#[path = "support/ops.rs"]
2	mod ops;	4	mod ops;
3		5
...	@@ -390,6 +392,7 @@ fn checkpoints_bound_dependencies_and_preserve_native_objects_and_history() {	...	@@ -390,6 +392,7 @@ fn checkpoints_bound_dependencies_and_preserve_native_objects_and_history() {
390	let store = Store::parse(&bytes).unwrap();	392	let store = Store::parse(&bytes).unwrap();
391	let before = RevisionIndex::parse(&store).unwrap();	393	let before = RevisionIndex::parse(&store).unwrap();
392	let rid = before.spaces[&sid].labels[&(ExGuid::default(), 1)];	394	let rid = before.spaces[&sid].labels[&(ExGuid::default(), 1)];
		395	let at = 134_000_000_000_000_000 + u64::from(operation) * 10_000_000;
393	let written = if section {	396	let written = if section {
394	let typed = \|range, with: &str\| Op::Page {	397	let typed = \|range, with: &str\| Op::Page {
395	space: sid,	398	space: sid,
...	@@ -400,7 +403,6 @@ fn checkpoints_bound_dependencies_and_preserve_native_objects_and_history() {	...	@@ -400,7 +403,6 @@ fn checkpoints_bound_dependencies_and_preserve_native_objects_and_history() {
400	},	403	},
401	};	404	};
402	// Modification times count seconds: each edit is a second later.	405	// Modification times count seconds: each edit is a second later.
403	let at = 134_000_000_000_000_000 + u64::from(operation) * 10_000_000;
404	let ops = vec![typed(0..0, "x"), typed(0..1, "")];	406	let ops = vec![typed(0..0, "x"), typed(0..1, "")];
405	let arena = onestore::Arena::default();	407	let arena = onestore::Arena::default();
406	let mut section = onestore::Section::open(&arena, bytes.clone()).unwrap();	408	let mut section = onestore::Section::open(&arena, bytes.clone()).unwrap();
...	@@ -428,6 +430,9 @@ fn checkpoints_bound_dependencies_and_preserve_native_objects_and_history() {	...	@@ -428,6 +430,9 @@ fn checkpoints_bound_dependencies_and_preserve_native_objects_and_history() {
428	assert_preserved_committed_bytes(&bytes, &written);	430	assert_preserved_committed_bytes(&bytes, &written);
429	let old = before.resolve(sid, rid).unwrap();	431	let old = before.resolve(sid, rid).unwrap();
430	let current = after.resolve(sid, next).unwrap();	432	let current = after.resolve(sid, next).unwrap();
		433	if section {
		434	assert_eq!(metadata::check(&old, &current, "Author"), at);
		435	}
431	assert_eq!(old.roots, current.roots);	436	assert_eq!(old.roots, current.roots);
432	assert_eq!(old.objects.len(), current.objects.len());	437	assert_eq!(old.objects.len(), current.objects.len());
433	for (id, object) in &old.objects {	438	for (id, object) in &old.objects {
...	@@ -456,7 +461,11 @@ fn checkpoints_bound_dependencies_and_preserve_native_objects_and_history() {	...	@@ -456,7 +461,11 @@ fn checkpoints_bound_dependencies_and_preserve_native_objects_and_history() {
456	assert_eq!(a.len(), b.len());	461	assert_eq!(a.len(), b.len());
457	for (a, b) in a.iter().zip(b) {	462	for (a, b) in a.iter().zip(b) {
458	assert_eq!(a.id, b.id);	463	assert_eq!(a.id, b.id);
459	if a.id != property && !matches!(a.value, Value::References { .. })	464	if a.id != property
		465	&& !(section
		466	&& Some(id) == old.roots.get(&4)
		467	&& a.id == 0x18001d77)
		468	&& !matches!(a.value, Value::References { .. })
460	{	469	{
461	assert_eq!(a.value, b.value, "{id} {:#x}", a.id);	470	assert_eq!(a.value, b.value, "{id} {:#x}", a.id);
462	}	471	}