| ... | ... | @@ -873,12 +873,12 @@ fn report(token: &str, label: &str, server: &Server, devices: &[Device]) { |
| 873 | 873 | eprintln!("{line}"); |
| 874 | 874 | } |
| 875 | 875 | |
| 876 | | /// A section as Snowbound makes it, three titled pages no one has edited yet, and its pages. |
| 877 | | fn untouched() -> (Vec<u8>, Vec<(ExGuid, Page)>) { |
| 876 | /// A section as Snowbound makes it, `count` titled pages no one has edited yet, and its pages. |
| 877 | fn untouched(count: usize) -> (Vec<u8>, Vec<(ExGuid, Page)>) { |
| 878 | 878 | let source = onestore::create_empty_section("first.one", None).unwrap(); |
| 879 | 879 | let arena = onestore::Arena::default(); |
| 880 | 880 | let mut section = Section::open(&arena, source).unwrap(); |
| 881 | | for n in 0..3 { |
| 881 | for n in 0..count { |
| 882 | 882 | let creation = PageCreation::new(None, Some(&format!("Page {n}")), "Fixture").unwrap(); |
| 883 | 883 | edit( |
| 884 | 884 | &mut section, |
| ... | ... | @@ -896,53 +896,46 @@ fn untouched() -> (Vec<u8>, Vec<(ExGuid, Page)>) { |
| 896 | 896 | (section.image(), pages) |
| 897 | 897 | } |
| 898 | 898 | |
| 899 | | /// Two devices each make one edit to `source`, then the one whose upload became the file |
| 900 | | /// merges the other's, a conflict version; returns the file. |
| 901 | | fn merged_first_edits(source: &[u8], edits: &[Vec<Op>; 2], winner: usize) -> Vec<u8> { |
| 899 | const DEVICES: [&str; 2] = ["Mac", "iPhone"]; |
| 900 | |
| 901 | /// The copies two devices make of `source`, each publishing its edit to its own. |
| 902 | fn diverged(source: &[u8], edits: &[Vec<Op>; 2]) -> [Vec<u8>; 2] { |
| 903 | [0, 1].map(|n| { |
| 904 | let arena = onestore::Arena::default(); |
| 905 | let mut section = Section::open(&arena, source.to_vec()).unwrap(); |
| 906 | edit(&mut section, DEVICES[n], edits[n].clone()); |
| 907 | section.seal().unwrap(); |
| 908 | section.image() |
| 909 | }) |
| 910 | } |
| 911 | |
| 912 | /// The file once the device whose copy it is has merged the other's, a conflict version. |
| 913 | fn merged(copies: &[Vec<u8>; 2], winner: usize) -> Vec<u8> { |
| 902 | 914 | let directory = tempfile::tempdir().unwrap(); |
| 915 | let file = &copies[winner]; |
| 903 | 916 | let mut server = Server { |
| 904 | | current: source.to_vec(), |
| 905 | | id: 0, |
| 906 | | next: 0, |
| 907 | | conflicts: Vec::new(), |
| 917 | current: file.clone(), |
| 918 | id: 1, |
| 919 | next: 1, |
| 920 | conflicts: vec![(2, copies[1 - winner].clone(), DEVICES[1 - winner].into())], |
| 908 | 921 | kept: 0, |
| 909 | 922 | }; |
| 910 | | let mut devices: Vec<Device> = ["Mac", "iPhone"] |
| 911 | | .into_iter() |
| 912 | | .enumerate() |
| 913 | | .map(|(n, name)| Device { |
| 914 | | name: name.into(), |
| 915 | | copy: Copy { |
| 916 | | bytes: source.to_vec(), |
| 917 | | base: 0, |
| 918 | | dirty: false, |
| 919 | | versions: Vec::new(), |
| 920 | | online: true, |
| 921 | | }, |
| 922 | | replica: Replica::create(directory.path().join(format!("{n}.sqlite")), source).unwrap(), |
| 923 | | }) |
| 924 | | .collect(); |
| 925 | | for (device, ops) in devices.iter_mut().zip(edits) { |
| 926 | | let edit = Edit { |
| 927 | | at: crate_now(), |
| 928 | | ops: ops.clone(), |
| 929 | | }; |
| 930 | | device.replica.apply(&device.name, edit).unwrap(); |
| 931 | | device.sync(&mut server); |
| 932 | | } |
| 933 | | let lost = &devices[1 - winner]; |
| 934 | | let lost = (server.next(), lost.copy.bytes.clone(), lost.name.clone()); |
| 935 | | server.conflicts.push(lost); |
| 936 | | server.current = devices[winner].copy.bytes.clone(); |
| 937 | | server.id = server.next(); |
| 938 | | let device = &mut devices[winner]; |
| 939 | | device.copy.base = server.id; |
| 940 | | device.copy.dirty = false; |
| 923 | let mut device = Device { |
| 924 | name: DEVICES[winner].into(), |
| 925 | copy: Copy { |
| 926 | bytes: file.clone(), |
| 927 | base: 1, |
| 928 | dirty: false, |
| 929 | versions: Vec::new(), |
| 930 | online: true, |
| 931 | }, |
| 932 | replica: Replica::create(directory.path().join("replica.sqlite"), file).unwrap(), |
| 933 | }; |
| 941 | 934 | device.deliver(&server); |
| 942 | 935 | device.sync(&mut server); |
| 943 | 936 | assert!(server.conflicts.is_empty()); |
| 944 | 937 | assert_eq!(server.kept, 0, "the version was set aside whole"); |
| 945 | | device.copy.bytes.clone() |
| 938 | device.copy.bytes |
| 946 | 939 | } |
| 947 | 940 | |
| 948 | 941 | fn title(page: &Page) -> &TextObject { |
| ... | ... | @@ -973,7 +966,7 @@ fn typing_title((space, page): &(ExGuid, Page), with: &str) -> Op { |
| 973 | 966 | /// set aside. |
| 974 | 967 | #[test] |
| 975 | 968 | fn first_edits_on_two_devices_merge_as_edits() { |
| 976 | | let (source, pages) = untouched(); |
| 969 | let (source, pages) = untouched(3); |
| 977 | 970 | let (space, page) = &pages[0]; |
| 978 | 971 | let body = lower_page(page, &with_body(page, "Typed on the iPhone.")) |
| 979 | 972 | .unwrap() |
| ... | ... | @@ -982,7 +975,7 @@ fn first_edits_on_two_devices_merge_as_edits() { |
| 982 | 975 | .collect(); |
| 983 | 976 | let edits = [vec![typing_title(&pages[0], "Mac: ")], body]; |
| 984 | 977 | for winner in 0..2 { |
| 985 | | let image = merged_first_edits(&source, &edits, winner); |
| 978 | let image = merged(&diverged(&source, &edits), winner); |
| 986 | 979 | let (listed, conflicts) = texts_of(&image); |
| 987 | 980 | assert!(conflicts.is_empty(), "{winner}: {conflicts}"); |
| 988 | 981 | assert!( |
| ... | ... | @@ -995,11 +988,11 @@ fn first_edits_on_two_devices_merge_as_edits() { |
| 995 | 988 | /// First edits that clash still leave OneNote's conflict page. |
| 996 | 989 | #[test] |
| 997 | 990 | fn clashing_first_edits_leave_a_conflict_page() { |
| 998 | | let (source, pages) = untouched(); |
| 991 | let (source, pages) = untouched(3); |
| 999 | 992 | let typed = ["Mac: ", "iPhone: "]; |
| 1000 | 993 | let edits = typed.map(|with| vec![typing_title(&pages[0], with)]); |
| 1001 | 994 | for winner in 0..2 { |
| 1002 | | let image = merged_first_edits(&source, &edits, winner); |
| 995 | let image = merged(&diverged(&source, &edits), winner); |
| 1003 | 996 | let arena = onestore::Arena::default(); |
| 1004 | 997 | let mut section = Section::open(&arena, image).unwrap(); |
| 1005 | 998 | let conflicts = section.conflicts().unwrap(); |
| ... | ... | @@ -1017,7 +1010,7 @@ fn clashing_first_edits_leave_a_conflict_page() { |
| 1017 | 1010 | /// Pages a version moved and deleted stay so beside another device's first edit. |
| 1018 | 1011 | #[test] |
| 1019 | 1012 | fn page_moves_and_deletions_survive_a_first_edit_elsewhere() { |
| 1020 | | let (source, pages) = untouched(); |
| 1013 | let (source, pages) = untouched(3); |
| 1021 | 1014 | let reordering = vec![ |
| 1022 | 1015 | Op::Section(SectionOp::Pages(vec![ |
| 1023 | 1016 | PageEdit::move_to(pages[2].0, Some(pages[0].0), 1).unwrap(), |
| ... | ... | @@ -1026,7 +1019,7 @@ fn page_moves_and_deletions_survive_a_first_edit_elsewhere() { |
| 1026 | 1019 | ]; |
| 1027 | 1020 | let edits = [vec![typing_title(&pages[0], "Mac: ")], reordering]; |
| 1028 | 1021 | for winner in 0..2 { |
| 1029 | | let image = merged_first_edits(&source, &edits, winner); |
| 1022 | let image = merged(&diverged(&source, &edits), winner); |
| 1030 | 1023 | let arena = onestore::Arena::default(); |
| 1031 | 1024 | let mut section = Section::open(&arena, image).unwrap(); |
| 1032 | 1025 | let titles: Vec<String> = section |
| ... | ... | @@ -1039,3 +1032,177 @@ fn page_moves_and_deletions_survive_a_first_edit_elsewhere() { |
| 1039 | 1032 | assert!(section.conflicts().unwrap().is_empty(), "{winner}"); |
| 1040 | 1033 | } |
| 1041 | 1034 | } |
| 1035 | |
| 1036 | /// What the Mac and the iPhone do to four pages: the Mac types in the first page's title; the |
| 1037 | /// iPhone writes on the first and second pages, moves the fourth first and deletes the third. |
| 1038 | fn apart(pages: &[(ExGuid, Page)]) -> [Vec<Op>; 2] { |
| 1039 | let body = |(space, page): &(ExGuid, Page), text| { |
| 1040 | let space = *space; |
| 1041 | lower_page(page, &with_body(page, text)) |
| 1042 | .unwrap() |
| 1043 | .into_iter() |
| 1044 | .map(move |op| Op::Page { space, op }) |
| 1045 | }; |
| 1046 | let mut iphone: Vec<Op> = body(&pages[0], "Typed on the iPhone.") |
| 1047 | .chain(body(&pages[1], "Page 1 from the iPhone.")) |
| 1048 | .collect(); |
| 1049 | iphone.push(Op::Section(SectionOp::Pages(vec![ |
| 1050 | PageEdit::move_to(pages[3].0, Some(pages[0].0), 1).unwrap(), |
| 1051 | ]))); |
| 1052 | iphone.push(Op::Section(SectionOp::Delete(vec![pages[2].0]))); |
| 1053 | [vec![typing_title(&pages[0], "Mac: ")], iphone] |
| 1054 | } |
| 1055 | |
| 1056 | /// `apart`'s copies merged either way round, where the first page's two copies share no |
| 1057 | /// revision: that page stays the file's with the other kept beside it as a conflict page, and |
| 1058 | /// every other change merges. |
| 1059 | fn assert_merged_beside(copies: &[Vec<u8>; 2], pages: &[(ExGuid, Page)]) { |
| 1060 | let space = pages[0].0; |
| 1061 | for copy in copies { |
| 1062 | let store = onestore::Store::parse(copy).unwrap(); |
| 1063 | let index = onestore::RevisionIndex::parse(&store).unwrap(); |
| 1064 | let head = index.active(space).unwrap(); |
| 1065 | assert_eq!(index.spaces[&space].revisions[&head].dependency, None); |
| 1066 | } |
| 1067 | // Whether a page holds the Mac's edit and the iPhone's. |
| 1068 | let marks = |page: &Page| { |
| 1069 | ( |
| 1070 | title(page).text.text().starts_with("Mac: "), |
| 1071 | bodies(page) |
| 1072 | .iter() |
| 1073 | .any(|(_, text)| text == "Typed on the iPhone."), |
| 1074 | ) |
| 1075 | }; |
| 1076 | for winner in 0..2 { |
| 1077 | let image = merged(copies, winner); |
| 1078 | let arena = onestore::Arena::default(); |
| 1079 | let mut section = Section::open(&arena, image).unwrap(); |
| 1080 | let titles: Vec<String> = section |
| 1081 | .pages() |
| 1082 | .unwrap() |
| 1083 | .into_iter() |
| 1084 | .map(|(_, title, _)| title) |
| 1085 | .collect(); |
| 1086 | let first = ["Mac: Page 0", "Page 0"][winner]; |
| 1087 | assert_eq!(titles, ["Page 3", first, "Page 1"], "{winner}"); |
| 1088 | assert_eq!( |
| 1089 | bodies(&section.page(pages[1].0).unwrap())[0].1, |
| 1090 | "Page 1 from the iPhone." |
| 1091 | ); |
| 1092 | let conflicts = section.conflicts().unwrap(); |
| 1093 | let [(of, conflict)] = &conflicts[..] else { |
| 1094 | panic!("{winner}: {conflicts:?}") |
| 1095 | }; |
| 1096 | assert_eq!((*of, conflict.len()), (space, 1)); |
| 1097 | let page = section.page(space).unwrap(); |
| 1098 | assert_eq!(marks(&page), (winner == 0, winner == 1)); |
| 1099 | let beside = section.page(conflict[0].space).unwrap(); |
| 1100 | assert_eq!(marks(&beside), (winner == 1, winner == 0)); |
| 1101 | } |
| 1102 | } |
| 1103 | |
| 1104 | /// A page both devices edited past the chain cap, each with a checkpoint, merges as a |
| 1105 | /// conflict page; the rest of the version still merges. |
| 1106 | #[test] |
| 1107 | fn pages_checkpointed_on_both_devices_merge_as_conflict_pages() { |
| 1108 | let (source, pages) = untouched(4); |
| 1109 | let arena = onestore::Arena::default(); |
| 1110 | let mut section = Section::open(&arena, source).unwrap(); |
| 1111 | let (space, page) = &pages[0]; |
| 1112 | let body = lower_page(page, &with_body(page, "Body")) |
| 1113 | .unwrap() |
| 1114 | .into_iter() |
| 1115 | .map(|op| Op::Page { space: *space, op }) |
| 1116 | .collect(); |
| 1117 | edit(&mut section, "Fixture", body); |
| 1118 | section.seal().unwrap(); |
| 1119 | let (text, _) = bodies(&section.page(*space).unwrap())[0].clone(); |
| 1120 | for n in 0..510 { |
| 1121 | let (range, with) = if n % 2 == 0 { (0..0, "x") } else { (0..1, "") }; |
| 1122 | let op = PageOp::Text { |
| 1123 | text, |
| 1124 | range, |
| 1125 | with: with.into(), |
| 1126 | }; |
| 1127 | edit( |
| 1128 | &mut section, |
| 1129 | "Fixture", |
| 1130 | vec![Op::Page { space: *space, op }], |
| 1131 | ); |
| 1132 | section.seal().unwrap(); |
| 1133 | } |
| 1134 | let source = section.image(); |
| 1135 | let pages: Vec<(ExGuid, Page)> = pages |
| 1136 | .iter() |
| 1137 | .map(|(space, _)| (*space, section.page(*space).unwrap())) |
| 1138 | .collect(); |
| 1139 | assert_merged_beside(&diverged(&source, &apart(&pages)), &pages); |
| 1140 | } |
| 1141 | |
| 1142 | /// The same for sections written before #152, whose first edit to a page checkpointed: |
| 1143 | /// `corpus/icloud-merge/first-edit-checkpoints`. |
| 1144 | #[test] |
| 1145 | fn pages_first_edited_before_152_merge_as_conflict_pages() { |
| 1146 | let row = format!( |
| 1147 | "{}/../../corpus/icloud-merge/first-edit-checkpoints", |
| 1148 | env!("CARGO_MANIFEST_DIR") |
| 1149 | ); |
| 1150 | let copies = DEVICES.map(|device| std::fs::read(format!("{row}/{device}.one")).unwrap()); |
| 1151 | let arena = onestore::Arena::default(); |
| 1152 | let mut section = Section::open(&arena, copies[0].clone()).unwrap(); |
| 1153 | let pages: Vec<(ExGuid, Page)> = section |
| 1154 | .pages() |
| 1155 | .unwrap() |
| 1156 | .into_iter() |
| 1157 | .map(|(space, ..)| (space, section.page(space).unwrap())) |
| 1158 | .collect(); |
| 1159 | assert_merged_beside(&copies, &pages); |
| 1160 | } |
| 1161 | |
| 1162 | /// A page one device takes past the chain cap merges as edits with the other device's edits |
| 1163 | /// elsewhere: the file's state of the page is one the version passed through. |
| 1164 | #[test] |
| 1165 | fn a_page_past_the_chain_cap_on_one_device_merges_as_edits() { |
| 1166 | let (source, pages) = untouched(2); |
| 1167 | let arena = onestore::Arena::default(); |
| 1168 | let mut section = Section::open(&arena, source.clone()).unwrap(); |
| 1169 | for n in 0..521 { |
| 1170 | let with = if n == 520 { "Mac: " } else { "x" }; |
| 1171 | let mut op = typing_title(&pages[0], with); |
| 1172 | if let Op::Page { |
| 1173 | op: PageOp::Text { range, with, .. }, |
| 1174 | .. |
| 1175 | } = &mut op |
| 1176 | && n % 2 == 1 |
| 1177 | { |
| 1178 | *range = 0..1; |
| 1179 | with.clear(); |
| 1180 | } |
| 1181 | edit(&mut section, "Mac", vec![op]); |
| 1182 | section.seal().unwrap(); |
| 1183 | } |
| 1184 | let mac = section.image(); |
| 1185 | let store = onestore::Store::parse(&mac).unwrap(); |
| 1186 | let index = onestore::RevisionIndex::parse(&store).unwrap(); |
| 1187 | let space = &index.spaces[&pages[0].0]; |
| 1188 | let chain = std::iter::successors(index.active(pages[0].0).ok(), |rid| { |
| 1189 | space.revisions[rid].dependency |
| 1190 | }); |
| 1191 | assert!(chain.count() < 512); |
| 1192 | let (space, page) = &pages[1]; |
| 1193 | let body = lower_page(page, &with_body(page, "Page 1 from the iPhone.")) |
| 1194 | .unwrap() |
| 1195 | .into_iter() |
| 1196 | .map(|op| Op::Page { space: *space, op }) |
| 1197 | .collect(); |
| 1198 | let [_, iphone] = diverged(&source, &[Vec::new(), body]); |
| 1199 | for winner in 0..2 { |
| 1200 | let image = merged(&[mac.clone(), iphone.clone()], winner); |
| 1201 | let (listed, conflicts) = texts_of(&image); |
| 1202 | assert!(conflicts.is_empty(), "{winner}: {conflicts}"); |
| 1203 | assert_eq!( |
| 1204 | listed, "Mac: Page 0\nPage 1\nPage 1 from the iPhone.\n", |
| 1205 | "{winner}" |
| 1206 | ); |
| 1207 | } |
| 1208 | } |