1#[path = "support/checkpoint.rs"]
2mod checkpoint;
3#[path = "support/current.rs"]
4mod current;
5#[path = "support/disk.rs"]
6mod disk;
7#[path = "support/metadata.rs"]
8mod metadata;
9#[path = "support/ops.rs"]
10mod ops;
11#[path = "support/sweep.rs"]
12mod sweep;
13
14use onestore::{
15 ExGuid, RevisionIndex, Store, TextAttribute as A,
16 document::{Document, Kind},
17 op::{Edit, Op, PageOp},
18};
19use std::ops::Range;
20
21/// Where an insertion goes: a paragraph in a container before a child of it, or last; or a
22/// new outline at a point on the page.
23#[derive(Clone, Copy)]
24enum Place {
25 In(ExGuid, Option<ExGuid>),
26 Outline(f32, f32),
27}
28
29/// The ops inserting `text` at `place` with `formats` set over UTF-16 ranges of it, and the
30/// identities of the new paragraph (or outline) and text.
31fn insertion(
32 space: ExGuid,
33 place: Place,
34 text: &str,
35 formats: &[(Range<u32>, Vec<A>)],
36) -> (Vec<Op>, ExGuid, ExGuid) {
37 let paragraph = ops::paragraph(text);
38 let text = paragraph.text().unwrap().id;
39 let (op, object) = match place {
40 Place::In(container, before) => {
41 let id = paragraph.id;
42 let paragraphs = vec![paragraph];
43 (
44 PageOp::Insert {
45 container,
46 before,
47 paragraphs,
48 },
49 id,
50 )
51 }
52 Place::Outline(x, y) => {
53 let object = ops::outline(x, y, vec![paragraph]);
54 let id = object.id();
55 (
56 PageOp::Add {
57 object,
58 before: None,
59 },
60 id,
61 )
62 }
63 };
64 let mut result = vec![Op::Page { space, op }];
65 for (range, set) in formats {
66 let op = PageOp::Format {
67 text,
68 range: range.clone(),
69 set: set.clone(),
70 clear: Vec::new(),
71 };
72 result.push(Op::Page { space, op });
73 }
74 (result, object, text)
75}
76
77fn targets(source: &[u8]) -> (ExGuid, ExGuid, ExGuid, ExGuid, ExGuid) {
78 let store = Store::parse(source).unwrap();
79 let index = RevisionIndex::parse(&store).unwrap();
80 let document = Document::parse(&index).unwrap();
81 let (sid, page) = document.pages().unwrap()[0];
82 let space = &document.spaces[&sid];
83 let view = &space.revisions[&space.contexts[&ExGuid::default()]];
84 let outline = view.nodes[&page]
85 .children
86 .iter()
87 .copied()
88 .find(|id| matches!(view.nodes[id].kind, Kind::Outline { .. }))
89 .unwrap();
90 let paragraph = view.nodes[&outline].children[0];
91 let text = view.nodes[&paragraph].content[0];
92 (sid, page, outline, paragraph, text)
93}
94
95#[test]
96fn atomic_formatted_insertions_match_a_character_model_and_preserve_history() {
97 use serde_json::json;
98 let source = onestore::create_section("rich.one", "Original", "Author").unwrap();
99 let (sid, page, outline, _, _) = targets(&source);
100 let text = "abπŸ¦€ e\u{301} 東京\rEnd\t!";
101 let (plain, _, plain_text) = insertion(sid, Place::In(outline, None), text, &[]);
102 let base = ops::edited(&source, plain).unwrap();
103 let base_store = Store::parse(&base).unwrap();
104 let base_index = RevisionIndex::parse(&base_store).unwrap();
105 let base_doc = Document::parse(&base_index).unwrap();
106 let base_space = &base_doc.spaces[&sid];
107 let base_view = &base_space.revisions[&base_space.contexts[&ExGuid::default()]];
108 let default =
109 serde_json::to_value(&base_view.text_runs(plain_text).unwrap()[0].format).unwrap();
110 let offsets: Vec<u32> = std::iter::once(0)
111 .chain(text.chars().scan(0, |n, c| {
112 *n += c.len_utf16() as u32;
113 Some(*n)
114 }))
115 .collect();
116 let old_store = Store::parse(&source).unwrap();
117 let old_index = RevisionIndex::parse(&old_store).unwrap();
118 for seed in sweep::seeds(1..49, 48) {
119 let mut random = seed;
120 let mut expected: Vec<_> = text.chars().map(|c| (c, default.clone())).collect();
121 let mut formats = Vec::new();
122 // Descending construction also exercises the order formats apply in.
123 for i in (0..expected.len()).rev() {
124 random ^= random << 13;
125 random ^= random >> 7;
126 random ^= random << 17;
127 let (attributes, values) = match random % 8 {
128 0 => continue,
129 1 => (
130 vec![A::Bold(true), A::Underline(true)],
131 json!({"bold":true,"underline":true}),
132 ),
133 2 => (
134 vec![A::Italic(true), A::Strike(true)],
135 json!({"italic":true,"strike":true}),
136 ),
137 3 => (
138 vec![A::Font("Arial".into()), A::FontSize(13.5)],
139 json!({"font":"Arial","font_size":13.5}),
140 ),
141 4 => (
142 vec![
143 A::Color(Some([12, 34, 56])),
144 A::Highlight(Some([255, 255, 0])),
145 ],
146 json!({"color":0x38220c,"highlight":0x00ffff}),
147 ),
148 5 => (
149 vec![A::Superscript(true)],
150 json!({"superscript":true,"subscript":false}),
151 ),
152 6 => (
153 vec![A::Subscript(true)],
154 json!({"subscript":true,"superscript":false}),
155 ),
156 _ => (
157 vec![A::Bold(false), A::Color(None), A::Highlight(None)],
158 json!({"bold":false,"color":0xff000000_u32,"highlight":0xff000000_u32}),
159 ),
160 };
161 formats.push((offsets[i]..offsets[i + 1], attributes));
162 for (key, value) in values.as_object().unwrap() {
163 expected[i].1[key] = value.clone();
164 }
165 }
166 let place = if seed % 2 == 0 {
167 Place::Outline(72.0, 144.0)
168 } else {
169 Place::In(outline, None)
170 };
171 let (ops, _, inserted) = insertion(sid, place, text, &formats);
172 let edit = Edit {
173 at: ops::now(),
174 ops,
175 };
176 let restored: Edit = serde_json::from_slice(&serde_json::to_vec(&edit).unwrap()).unwrap();
177 assert_eq!(restored, edit);
178 let edited = ops::edited(&source, restored.ops).unwrap();
179 let store = Store::parse(&edited).unwrap();
180 assert_eq!(
181 store.header.transaction_count,
182 old_store.header.transaction_count + 1
183 );
184 let index = RevisionIndex::parse(&store).unwrap();
185 index.validate_current().unwrap();
186 assert_eq!(
187 index.spaces[&sid].revisions.len(),
188 old_index.spaces[&sid].revisions.len() + 1
189 );
190 for (space, old) in &old_index.spaces {
191 for revision in old.revisions.keys() {
192 assert_eq!(
193 format!("{:?}", old_index.resolve(*space, *revision).unwrap()),
194 format!("{:?}", index.resolve(*space, *revision).unwrap())
195 );
196 }
197 }
198 let document = Document::parse(&index).unwrap();
199 let space = &document.spaces[&sid];
200 let view = &space.revisions[&space.contexts[&ExGuid::default()]];
201 if let Place::Outline(..) = place {
202 assert!(view.nodes[&page].children.len() > 1);
203 }
204 let actual: Vec<_> = view
205 .text_runs(inserted)
206 .unwrap()
207 .into_iter()
208 .flat_map(|run| {
209 let format = serde_json::to_value(run.format).unwrap();
210 run.text.chars().map(move |c| (c, format.clone()))
211 })
212 .collect();
213 assert_eq!(actual, expected, "seed {seed}");
214 }
215}
216
217#[test]
218fn formatted_empty_insertions_preserve_the_insertion_style_for_later_typing() {
219 let source = onestore::create_section("empty-rich.one", "Original", "Author").unwrap();
220 let (sid, _, outline, _, _) = targets(&source);
221 for place in [Place::Outline(72.0, 144.0), Place::In(outline, None)] {
222 let style = [(0..0, vec![A::Italic(true), A::FontSize(18.0)])];
223 let (ops, _, text) = insertion(sid, place, "", &style);
224 let inserted = ops::edited(&source, ops).unwrap();
225 let typed = ops::page_edited(
226 &inserted,
227 sid,
228 vec![PageOp::Text {
229 text,
230 range: 0..0,
231 with: "Typed πŸ¦€".into(),
232 }],
233 )
234 .unwrap();
235 for (bytes, expected) in [(&inserted, ""), (&typed, "Typed πŸ¦€")] {
236 let store = Store::parse(bytes).unwrap();
237 let index = RevisionIndex::parse(&store).unwrap();
238 index.validate_current().unwrap();
239 let document = Document::parse(&index).unwrap();
240 let space = &document.spaces[&sid];
241 let view = &space.revisions[&space.contexts[&ExGuid::default()]];
242 let runs = view.text_runs(text).unwrap();
243 assert_eq!(runs.len(), 1);
244 assert_eq!(runs[0].text, expected);
245 assert_eq!(runs[0].format.italic, Some(true));
246 assert_eq!(runs[0].format.font_size, Some(18.0));
247 }
248 }
249}
250
251#[test]
252#[ignore = "exports formatted insertion candidates for cold native validation"]
253fn export_native_formatted_insertions() {
254 use std::{fs, path::PathBuf};
255 let output = PathBuf::from(std::env::var_os("ONESTORE_INSERT_OUTPUT").unwrap());
256 assert!(output.is_absolute());
257 fs::create_dir(&output).unwrap();
258 let generated = onestore::create_section("rich.one", "Original", "Author").unwrap();
259 let unicode = include_bytes!(
260 "../../../corpus/native/20260905-05/snapshots/03-format-unicode/notebook/synthetic.one"
261 );
262 let table = include_bytes!(
263 "../../../corpus/native/20260905-05/snapshots/07-table/notebook/synthetic.one"
264 );
265 let text = "Bold πŸ¦€ italic e\u{301} color 東京\rEnd";
266 let mut manifest = Vec::new();
267 for (name, source, empty) in [
268 ("outline", generated.as_slice(), false),
269 ("native-paragraph", unicode.as_slice(), false),
270 ("native-cell", table.as_slice(), false),
271 ("empty", generated.as_slice(), true),
272 ("empty-typed", generated.as_slice(), true),
273 ] {
274 let (sid, _, outline, paragraph, _) = targets(source);
275 let place = match name {
276 "native-paragraph" => Place::In(outline, Some(paragraph)),
277 "native-cell" => {
278 let store = Store::parse(source).unwrap();
279 let index = RevisionIndex::parse(&store).unwrap();
280 let document = Document::parse(&index).unwrap();
281 let space = &document.spaces[&sid];
282 let view = &space.revisions[&space.contexts[&ExGuid::default()]];
283 let cell = *view
284 .nodes
285 .iter()
286 .find(|(_, node)| matches!(node.kind, Kind::Cell { .. }))
287 .unwrap()
288 .0;
289 Place::In(cell, None)
290 }
291 _ => Place::Outline(72.0, 144.0),
292 };
293 let formats = if empty {
294 vec![(0..0, vec![A::Italic(true), A::FontSize(18.0)])]
295 } else {
296 [
297 ("Bold", vec![A::Bold(true), A::Underline(true)]),
298 ("πŸ¦€", vec![A::Font("Arial".into()), A::FontSize(13.5)]),
299 ("italic", vec![A::Italic(true), A::Strike(true)]),
300 ("e\u{301}", vec![A::Superscript(true)]),
301 (
302 "color",
303 vec![
304 A::Color(Some([12, 34, 56])),
305 A::Highlight(Some([255, 255, 0])),
306 ],
307 ),
308 ("東京", vec![A::Subscript(true)]),
309 (
310 "End",
311 vec![
312 A::Bold(false),
313 A::Italic(false),
314 A::Color(None),
315 A::Highlight(None),
316 ],
317 ),
318 ]
319 .into_iter()
320 .map(|(label, attributes)| {
321 let start = text[..text.find(label).unwrap()].encode_utf16().count() as u32;
322 (
323 start..start + label.encode_utf16().count() as u32,
324 attributes,
325 )
326 })
327 .collect()
328 };
329 let (mut ops, object, inserted) =
330 insertion(sid, place, if empty { "" } else { text }, &formats);
331 if name == "empty-typed" {
332 let op = PageOp::Text {
333 text: inserted,
334 range: 0..0,
335 with: "Typed café πŸ¦€".into(),
336 };
337 ops.push(Op::Page { space: sid, op });
338 }
339 let edit = Edit {
340 at: ops::now(),
341 ops,
342 };
343 let bytes = ops::edited(source, edit.ops.clone()).unwrap();
344 current::current(&bytes);
345 let notebook = output.join(name);
346 fs::create_dir(&notebook).unwrap();
347 fs::write(notebook.join("synthetic.one"), &bytes).unwrap();
348 manifest.push(serde_json::json!({
349 "name": name, "space": sid, "object": object, "text": inserted, "edit": edit
350 }));
351 }
352 fs::write(
353 output.join("manifest.json"),
354 serde_json::to_vec_pretty(&manifest).unwrap(),
355 )
356 .unwrap();
357}
358
359#[test]
360fn paragraph_and_outline_insertions_publish_metadata_and_references_together() {
361 let source = onestore::create_section("insertion.one", "Original", "Original author").unwrap();
362 let (sid, page, outline, paragraph, original_text) = targets(&source);
363 for (place, expected_parent, expected_x, expected_y) in [
364 (Place::In(outline, Some(paragraph)), outline, None, None),
365 (Place::Outline(144.0, 18.0), page, Some(144.0), Some(18.0)),
366 ] {
367 let (ops, object, text) = insertion(sid, place, "First πŸ¦€\rSecond", &[]);
368 let transaction = ops::transaction(&source, "New author", ops)
369 .unwrap()
370 .unwrap();
371 let mut written = source.clone();
372 transaction.apply(&mut written).unwrap();
373 let store = Store::parse(&written).unwrap();
374 assert_eq!(
375 store.header.transaction_count,
376 Store::parse(&source).unwrap().header.transaction_count + 1
377 );
378 let index = RevisionIndex::parse(&store).unwrap();
379 index.validate_current().unwrap();
380 let document = Document::parse(&index).unwrap();
381 let space = &document.spaces[&sid];
382 let view = &space.revisions[&space.contexts[&ExGuid::default()]];
383 assert!(view.nodes[&expected_parent].children.contains(&object));
384 assert_eq!(view.nodes[&object].layout.x, expected_x);
385 assert_eq!(view.nodes[&object].layout.y, expected_y);
386 assert!(
387 matches!(&view.nodes[&original_text].kind, Kind::RichText { text, .. } if text == "Original")
388 );
389 assert!(
390 matches!(&view.nodes[&text].kind, Kind::RichText { text, .. } if text == "First πŸ¦€\rSecond")
391 );
392 assert!(
393 matches!(&view.nodes[&page].kind, Kind::Page { alternate_title, .. } if alternate_title.as_deref() == Some("First πŸ¦€"))
394 );
395 assert!(
396 matches!(&view.nodes[&view.roots[&2]].kind, Kind::Metadata { title, .. } if title.as_deref() == Some("First πŸ¦€"))
397 );
398 assert!(
399 view.nodes
400 .values()
401 .any(|node| matches!(&node.kind, Kind::Author { name } if name.as_deref() == Some("New author")))
402 );
403 let runs = view.text_runs(text).unwrap();
404 assert_eq!(runs.len(), 1);
405 assert_eq!(runs[0].format.font.as_deref(), Some("Calibri"));
406 assert_eq!(runs[0].format.font_size, Some(11.0));
407 let previous_store = Store::parse(&source).unwrap();
408 let previous = RevisionIndex::parse(&previous_store).unwrap();
409 for (old_sid, old_space) in &previous.spaces {
410 for rid in old_space.revisions.keys() {
411 assert_eq!(
412 format!("{:?}", previous.resolve(*old_sid, *rid).unwrap()),
413 format!("{:?}", index.resolve(*old_sid, *rid).unwrap())
414 );
415 }
416 }
417 }
418}
419
420/// A page's first revision metadata depends on the revision before it and names only its
421/// new root, as OneNote 2010 typing on a Snowbound page does (`corpus/link-edit/native-typed`).
422#[test]
423fn first_revision_metadata_extends_the_chain_and_keeps_history() {
424 let source = onestore::create_section("metadata.one", "Original", "Same author").unwrap();
425 let (sid, _, _, _, text) = targets(&source);
426 let store = Store::parse(&source).unwrap();
427 let index = RevisionIndex::parse(&store).unwrap();
428 let original = index.resolve_active(sid).unwrap();
429 assert!(!original.roots.contains_key(&4));
430 let arena = onestore::Arena::default();
431 let mut section = onestore::Section::open(&arena, source.clone()).unwrap();
432 let at = 134_000_000_000_012_345;
433 let mut previous = Some(index.active(sid).unwrap());
434 for (at, roles) in [(at, &[4][..]), (at + 1, &[])] {
435 section
436 .apply(
437 "Same author",
438 &Edit {
439 at,
440 ops: vec![Op::Page {
441 space: sid,
442 op: PageOp::Text {
443 text,
444 range: 0..0,
445 with: "x".into(),
446 },
447 }],
448 },
449 )
450 .unwrap();
451 section.seal().unwrap().unwrap();
452 let image = section.image();
453 let current_store = Store::parse(&image).unwrap();
454 let current = RevisionIndex::parse(&current_store).unwrap();
455 current.validate_current().unwrap();
456 let rid = current.active(sid).unwrap();
457 let stored = &current.spaces[&sid].revisions[&rid];
458 assert_eq!(stored.dependency, previous);
459 let declared: Vec<u32> = stored
460 .nodes
461 .iter()
462 .filter(|node| node.id == 0x5a)
463 .map(|node| u32::from_le_bytes(node.payload[20..].try_into().unwrap()))
464 .collect();
465 assert_eq!(declared, roles);
466 let revision = current.resolve_active(sid).unwrap();
467 assert_eq!(metadata::check(&original, &revision, "Same author"), at);
468 assert!(
469 revision
470 .objects
471 .keys()
472 .all(|id| original.objects.contains_key(id) || *id == revision.roots[&4])
473 );
474 for old in index.spaces[&sid].revisions.keys() {
475 assert_eq!(
476 format!("{:?}", index.resolve(sid, *old).unwrap()),
477 format!("{:?}", current.resolve(sid, *old).unwrap())
478 );
479 }
480 previous = Some(rid);
481 }
482}
483
484#[test]
485fn repeated_insertions_and_formatting_share_immutable_objects() {
486 let mut source = onestore::create_section("shared.one", "Original", "Same author").unwrap();
487 let (sid, _, outline, _, _) = targets(&source);
488 let mut texts = Vec::new();
489 for _ in 0..12 {
490 let (ops, _, text) = insertion(sid, Place::In(outline, None), "Repeated paragraph", &[]);
491 let transaction = ops::transaction(&source, "Same author", ops)
492 .unwrap()
493 .unwrap();
494 transaction.apply(&mut source).unwrap();
495 let bold = PageOp::Format {
496 text,
497 range: 1..8,
498 set: vec![A::Bold(true), A::FontSize(20.0)],
499 clear: Vec::new(),
500 };
501 let transaction = ops::transaction(
502 &source,
503 "Same author",
504 vec![Op::Page {
505 space: sid,
506 op: bold,
507 }],
508 )
509 .unwrap()
510 .unwrap();
511 transaction.apply(&mut source).unwrap();
512 texts.push(text);
513 }
514 let store = Store::parse(&source).unwrap();
515 let index = RevisionIndex::parse(&store).unwrap();
516 index.validate_current().unwrap();
517 let raw = index
518 .resolve(sid, index.spaces[&sid].labels[&(ExGuid::default(), 1)])
519 .unwrap();
520 let mut unique = std::collections::BTreeSet::new();
521 let mut counts = Vec::new();
522 for id in raw.reachable().unwrap() {
523 let object = &raw.objects[&id];
524 if object.jcid & 0x100000 == 0 {
525 continue;
526 }
527 let onestore::ObjectData::Properties(bytes) = object.data else {
528 panic!()
529 };
530 assert!(
531 unique.insert((object.jcid, bytes.to_vec())),
532 "Duplicate immutable object"
533 );
534 counts.push((object.jcid, object.reference_count));
535 }
536 counts.sort();
537 metadata::check(&raw, &raw, "Same author");
538 let author = metadata::author(&raw.objects[&raw.roots[&4]]);
539 assert_eq!(raw.objects[&author].jcid, 0x120001);
540 assert_eq!(counts, [(0x120001, 27), (0x12004d, 12), (0x12004d, 25)]);
541 let document = Document::parse(&index).unwrap();
542 let space = &document.spaces[&sid];
543 let view = &space.revisions[&space.contexts[&ExGuid::default()]];
544 for text in texts {
545 let runs = view.text_runs(text).unwrap();
546 assert_eq!(runs.len(), 3);
547 assert_eq!(runs[1].format.bold, Some(true));
548 assert_eq!(runs[1].format.font_size, Some(20.0));
549 }
550}
551
552#[test]
553fn serialized_insertions_rebase_with_the_same_objects_and_preserve_remote_edits() {
554 let source = onestore::create_section("rebase.one", "Original", "Author").unwrap();
555 let (sid, _, outline, paragraph, text) = targets(&source);
556 let formats = [(0..3, vec![A::Bold(true), A::Color(Some([12, 34, 56]))])];
557 let (ops, object, inserted) = insertion(
558 sid,
559 Place::In(outline, Some(paragraph)),
560 "Inserted",
561 &formats,
562 );
563 let encoded = serde_json::to_vec(&ops).unwrap();
564 let restored: Vec<Op> = serde_json::from_slice(&encoded).unwrap();
565 assert_eq!(ops, restored);
566 let original = ops::edited(&source, ops).unwrap();
567 let remote = ops::page_edited(
568 &source,
569 sid,
570 vec![PageOp::Text {
571 text,
572 range: 0..0,
573 with: "Remote ".into(),
574 }],
575 )
576 .unwrap();
577 let updated = ops::edited(&remote, restored.clone()).unwrap();
578 let store = Store::parse(&updated).unwrap();
579 let index = RevisionIndex::parse(&store).unwrap();
580 let document = Document::parse(&index).unwrap();
581 let space = &document.spaces[&sid];
582 let view = &space.revisions[&space.contexts[&ExGuid::default()]];
583 assert_eq!(view.nodes[&outline].children, [object, paragraph]);
584 assert!(
585 matches!(&view.nodes[&text].kind, Kind::RichText { text, .. } if text == "Remote Original")
586 );
587 assert!(
588 matches!(&view.nodes[&inserted].kind, Kind::RichText { text, .. } if text == "Inserted")
589 );
590 let runs = view.text_runs(inserted).unwrap();
591 assert_eq!(runs[0].text, "Ins");
592 assert_eq!(runs[0].format.bold, Some(true));
593 assert_eq!(runs[0].format.color, Some(0x38220c));
594 assert_eq!(runs[1].text, "erted");
595 assert_ne!(runs[1].format.bold, Some(true));
596 assert!(ops::edited(&original, restored.clone()).is_err());
597 assert!(ops::edited(&updated, restored).is_err());
598}
599
600#[test]
601#[cfg(any(unix, windows))]
602fn filesystem_insertion_commits_once_and_rejects_stale_replay() {
603 use std::{fs, io::Write};
604 let source = onestore::create_section("file.one", "Original", "Author").unwrap();
605 let (sid, _, outline, _, _) = targets(&source);
606 let (ops, object, _) = insertion(sid, Place::In(outline, None), "File insertion", &[]);
607 let path = std::env::temp_dir().join(format!("onestore-insertion-{object}.one"));
608 let mut file = fs::OpenOptions::new()
609 .write(true)
610 .create_new(true)
611 .open(&path)
612 .unwrap();
613 file.write_all(&source).unwrap();
614 file.sync_all().unwrap();
615 drop(file);
616 let transaction = ops::transaction(&source, "Author", ops).unwrap().unwrap();
617 let result = transaction.commit_file(&path);
618 let written = onestore::read_file(&path).unwrap();
619 let repeated = transaction.commit_file(&path).unwrap_err();
620 fs::remove_file(path).unwrap();
621 result.unwrap();
622 let mut expected = source.clone();
623 transaction.apply(&mut expected).unwrap();
624 assert_eq!(written, expected);
625 assert_eq!(repeated.state, onestore::CommitState::NotCommitted);
626 assert_eq!(repeated.error.kind(), std::io::ErrorKind::ResourceBusy);
627}
628
629#[test]
630fn anchors_targets_identities_and_text_are_validated_before_publication() {
631 let source = onestore::create_section("invalid.one", "Original", "Author").unwrap();
632 let (sid, page, outline, _, text) = targets(&source);
633 let refused = |source: &[u8], place, content: &str| {
634 ops::edited(source, insertion(sid, place, content, &[]).0).is_err()
635 };
636 assert!(refused(&source, Place::Outline(f32::NAN, 0.0), "Text"));
637 assert!(refused(&source, Place::Outline(0.0, f32::INFINITY), "Text"));
638 for content in ["a\0b", "a\nb", "a\u{fffc}b"] {
639 assert!(refused(&source, Place::In(outline, None), content));
640 }
641 assert!(
642 ops::transaction(
643 &source,
644 "a\0b",
645 insertion(sid, Place::In(outline, None), "Text", &[]).0
646 )
647 .is_err()
648 );
649 for place in [
650 Place::In(outline, Some(text)),
651 Place::In(text, None),
652 Place::In(page, None),
653 ] {
654 assert!(refused(&source, place, "Text"));
655 }
656 let (ops, object, _) = insertion(sid, Place::In(outline, None), "Text", &[]);
657 let created = ops::edited(&source, ops.clone()).unwrap();
658 let before_created = Place::In(outline, Some(object));
659 assert!(refused(&source, before_created, "Anchored"));
660 assert!(!refused(&created, before_created, "Anchored"));
661 // A new object's identity may not already be on the page.
662 assert!(ops::edited(&created, ops).is_err());
663}
664
665#[test]
666fn insertions_into_nested_paragraphs_and_native_table_cells_preserve_structure() {
667 let source = onestore::create_section("nested.one", "Original", "Author").unwrap();
668 let (sid, _, outline, paragraph, _) = targets(&source);
669 let mut nested = ops::paragraph("Nested");
670 nested.level = 2;
671 let child = nested.id;
672 let insert = PageOp::Insert {
673 container: paragraph,
674 before: None,
675 paragraphs: vec![nested],
676 };
677 let changed = ops::page_edited(&source, sid, vec![insert]).unwrap();
678 let store = Store::parse(&changed).unwrap();
679 let index = RevisionIndex::parse(&store).unwrap();
680 let document = Document::parse(&index).unwrap();
681 let space = &document.spaces[&sid];
682 let view = &space.revisions[&space.contexts[&ExGuid::default()]];
683 assert_eq!(view.nodes[&outline].children, [paragraph]);
684 assert_eq!(view.nodes[&paragraph].children, [child]);
685 let source = include_bytes!(
686 "../../../corpus/native/20260905-05/snapshots/07-table/notebook/synthetic.one"
687 );
688 let store = Store::parse(source).unwrap();
689 let index = RevisionIndex::parse(&store).unwrap();
690 let document = Document::parse(&index).unwrap();
691 let (sid, cell) = document
692 .spaces
693 .iter()
694 .find_map(|(sid, space)| {
695 let view = &space.revisions[&space.contexts[&ExGuid::default()]];
696 view.nodes.iter().find_map(|(id, node)| {
697 matches!(node.kind, Kind::Cell { .. }).then_some((*sid, *id))
698 })
699 })
700 .unwrap();
701 let (ops, _, _) = insertion(sid, Place::In(cell, None), "Added to cell", &[]);
702 current::current(&ops::edited(source, ops).unwrap());
703}
704
705#[test]
706fn insertion_publication_faults_expose_only_complete_graphs_and_title_caches() {
707 let original = onestore::create_section("atomic.one", "Original", "Author").unwrap();
708 let (sid, _, _, _, text) = targets(&original);
709 let checkpoint = checkpoint::pending(&original, sid, text);
710 for source in [
711 original.as_slice(),
712 include_bytes!("../../../corpus/append/round-01/tx-255/notebook/synthetic.one"),
713 &checkpoint,
714 ] {
715 let (sid, _, outline, paragraph, _) = targets(source);
716 for place in [
717 Place::In(outline, Some(paragraph)),
718 Place::Outline(0.0, 0.0),
719 ] {
720 let formats = [
721 (0..3, vec![A::Bold(true), A::FontSize(18.0)]),
722 (
723 6..8,
724 vec![A::Italic(true), A::Highlight(Some([255, 255, 0]))],
725 ),
726 ];
727 let (ops, _, _) = insertion(sid, place, "First πŸ¦€", &formats);
728 let edit = ops::transaction(source, "New author", ops)
729 .unwrap()
730 .unwrap();
731 let mut written = source.to_vec();
732 edit.apply(&mut written).unwrap();
733 let before = current::current(source);
734 let after = current::current(&written);
735 for write_limit in [17, 4096] {
736 let disk = |fail_at| disk::Disk {
737 visible: source.to_vec(),
738 durable: source.to_vec(),
739 operation: 0,
740 fail_at,
741 write_limit,
742 random: 945,
743 };
744 let mut successful = disk(None);
745 edit.commit(&mut successful).unwrap();
746 assert_eq!(successful.durable, written);
747 for at in 1..=successful.operation {
748 let mut interrupted = disk(Some(at));
749 let failure = edit.commit(&mut interrupted).unwrap_err();
750 let state = current::current(&interrupted.durable);
751 assert!(state == before || state == after, "interruption {at}");
752 if failure.state == onestore::CommitState::NotCommitted {
753 assert_eq!(state, before);
754 }
755 if failure.state == onestore::CommitState::Committed {
756 assert_eq!(state, after);
757 }
758 }
759 }
760 }
761 }
762}