oxedyne/fe2o3/fe2o3_jdat/tests/json_edit.rs
9.8 KiB, 10 runs
created by r1870400018:75871, which is this file's identity for as long as the history lasts, whatever it is later renamed to
download ยท who wrote it ยท its history
| 1 | //! `JsonObjectText`, the editor of one JSON object's text in place: every byte outside the members |
| 2 | //! it is asked to change comes back as it was, and text that is not one JSON object is refused. |
| 3 | |
| 4 | use oxedyne_fe2o3_core::prelude::*; |
| 5 | use oxedyne_fe2o3_jdat::bdat::DecodeLimits; |
| 6 | use oxedyne_fe2o3_jdat::string::json_edit::JsonObjectText; |
| 7 | use oxedyne_fe2o3_jdat::string::json_edit::element_spans; |
| 8 | use oxedyne_fe2o3_jdat::string::json_edit::member; |
| 9 | |
| 10 | |
| 11 | fn edit(s: &str) -> JsonObjectText { |
| 12 | match JsonObjectText::new(s) { |
| 13 | Ok(o) => o, |
| 14 | Err(e) => panic!("{:?} must read as one JSON object: {}", s, e), |
| 15 | } |
| 16 | } |
| 17 | |
| 18 | #[test] |
| 19 | fn test_set_replaces_only_the_value_00() -> Outcome<()> { |
| 20 | let mut o = edit(r#"{"s":"x", "n":1, "a":[1,{"b":"}"}]}"#); |
| 21 | res!(o.set("s", "\"y\"")); |
| 22 | assert_eq!(o.as_str(), r#"{"s":"y", "n":1, "a":[1,{"b":"}"}]}"#); |
| 23 | res!(o.set("a", "null")); |
| 24 | assert_eq!(o.as_str(), r#"{"s":"y", "n":1, "a":null}"#); |
| 25 | Ok(()) |
| 26 | } |
| 27 | |
| 28 | #[test] |
| 29 | fn test_set_adds_a_missing_member_at_the_end_00() -> Outcome<()> { |
| 30 | let mut o = edit(r#"{"a":1 }"#); |
| 31 | res!(o.set("z", "0")); |
| 32 | assert_eq!(o.as_str(), r#"{"a":1,"z":0 }"#); |
| 33 | let mut e = edit("{}"); |
| 34 | res!(e.set("z", "0")); |
| 35 | assert_eq!(e.as_str(), r#"{"z":0}"#); |
| 36 | // A key that needs escaping is written escaped, and found again by what it says. |
| 37 | res!(e.set("q\"k", "true")); |
| 38 | assert_eq!(e.as_str(), r#"{"z":0,"q\"k":true}"#); |
| 39 | assert_eq!(e.get("q\"k"), Some("true")); |
| 40 | Ok(()) |
| 41 | } |
| 42 | |
| 43 | #[test] |
| 44 | fn test_remove_takes_the_member_and_one_comma_00() -> Outcome<()> { |
| 45 | let raw = r#"{"a":1, "s":"{x}", "n":2}"#; |
| 46 | let mut first = edit(raw); |
| 47 | assert!(res!(first.remove("a"))); |
| 48 | assert_eq!(first.as_str(), r#"{"s":"{x}", "n":2}"#); |
| 49 | let mut mid = edit(raw); |
| 50 | assert!(res!(mid.remove("s"))); |
| 51 | assert_eq!(mid.as_str(), r#"{"a":1, "n":2}"#); |
| 52 | let mut last = edit(raw); |
| 53 | assert!(res!(last.remove("n"))); |
| 54 | assert_eq!(last.as_str(), r#"{"a":1, "s":"{x}"}"#); |
| 55 | let mut only = edit(r#"{ "z":0 }"#); |
| 56 | assert!(res!(only.remove("z"))); |
| 57 | assert_eq!(only.as_str(), "{ }"); |
| 58 | assert!(!res!(only.remove("z")), "a key not there is no fault and changes nothing"); |
| 59 | assert_eq!(only.as_str(), "{ }"); |
| 60 | Ok(()) |
| 61 | } |
| 62 | |
| 63 | #[test] |
| 64 | fn test_braces_and_quotes_inside_strings_are_not_structure_00() -> Outcome<()> { |
| 65 | let mut o = edit(r#"{"note":"a } b, \"c\": {d", "k":"v"}"#); |
| 66 | assert_eq!(o.get("k"), Some("\"v\"")); |
| 67 | res!(o.set("k", "\"w\"")); |
| 68 | assert_eq!(o.as_str(), r#"{"note":"a } b, \"c\": {d", "k":"w"}"#); |
| 69 | assert_eq!(o.keys(), vec![fmt!("note"), fmt!("k")]); |
| 70 | Ok(()) |
| 71 | } |
| 72 | |
| 73 | #[test] |
| 74 | fn test_a_nested_member_of_the_same_name_is_left_alone_00() -> Outcome<()> { |
| 75 | let mut o = edit(r#"{"in":{"k":1,"deep":[{"k":2}]},"k":3}"#); |
| 76 | res!(o.set("k", "4")); |
| 77 | assert_eq!(o.as_str(), r#"{"in":{"k":1,"deep":[{"k":2}]},"k":4}"#); |
| 78 | assert!(res!(o.remove("k"))); |
| 79 | assert_eq!(o.as_str(), r#"{"in":{"k":1,"deep":[{"k":2}]}}"#); |
| 80 | Ok(()) |
| 81 | } |
| 82 | |
| 83 | #[test] |
| 84 | fn test_layout_and_line_endings_are_kept_00() -> Outcome<()> { |
| 85 | let mut o = edit("{\r\n \"a\": 1,\r\n \"b\": \"x\"\r\n}\r\n"); |
| 86 | res!(o.set("a", "2")); |
| 87 | assert_eq!(o.as_str(), "{\r\n \"a\": 2,\r\n \"b\": \"x\"\r\n}\r\n"); |
| 88 | Ok(()) |
| 89 | } |
| 90 | |
| 91 | #[test] |
| 92 | fn test_unknown_members_survive_an_edit_byte_for_byte_00() -> Outcome<()> { |
| 93 | let raw = r#"{"id":"7","x-new":{"u":[1.50e3,"รฉ"]},"rel":"Cites","t":-0.0}"#; |
| 94 | let mut o = edit(raw); |
| 95 | res!(o.set("rel", "\"cites\"")); |
| 96 | res!(o.set("share", "true")); |
| 97 | assert!(res!(o.remove("share"))); |
| 98 | assert_eq!(o.as_str(), raw.replace("Cites", "cites")); |
| 99 | Ok(()) |
| 100 | } |
| 101 | |
| 102 | #[test] |
| 103 | fn test_what_is_not_one_object_is_refused_00() { |
| 104 | for bad in [ |
| 105 | "", |
| 106 | "[1]", |
| 107 | "\"s\"", |
| 108 | r#"{"a":1} trailing"#, |
| 109 | r#"{"a":1}{"b":2}"#, |
| 110 | r#"{"a":"open"#, |
| 111 | r#"{"a":1,}"#, |
| 112 | r#"{a:1}"#, |
| 113 | r#"{"a":01}"#, |
| 114 | r#"{"a":tru}"#, |
| 115 | r#"{"a":1,"a":2}"#, // a member named twice has no one meaning to edit |
| 116 | "{\"a\":\"\u{1}\"}", // a raw control character in a string |
| 117 | ] { |
| 118 | assert!(JsonObjectText::new(bad).is_err(), "{:?} must be refused", bad); |
| 119 | } |
| 120 | } |
| 121 | |
| 122 | #[test] |
| 123 | fn test_a_value_that_is_not_one_json_value_is_refused_00() { |
| 124 | let mut o = edit(r#"{"a":1}"#); |
| 125 | for bad in ["", "1 2", "1,\"b\":2", "{", "'s'", "x"] { |
| 126 | assert!(o.set("a", bad).is_err(), "{:?} must be refused as a value", bad); |
| 127 | assert_eq!(o.as_str(), r#"{"a":1}"#, "a refused set changes nothing"); |
| 128 | } |
| 129 | } |
| 130 | |
| 131 | #[test] |
| 132 | fn test_the_grammar_is_held_inside_values_too_00() { |
| 133 | for bad in [ |
| 134 | r#"{"a":{"b":1,"b":2}}"#, // a nested member named twice |
| 135 | r#"{"a":"\ud800"}"#, // half a surrogate pair |
| 136 | r#"{"a":"\x"}"#, // an escape JSON does not have |
| 137 | r#"{"a":[1,]}"#, |
| 138 | r#"{"a":1.}"#, |
| 139 | r#"{"a":-}"#, |
| 140 | r#"{"a":1e}"#, |
| 141 | ] { |
| 142 | assert!(JsonObjectText::new(bad).is_err(), "{:?} must be refused", bad); |
| 143 | } |
| 144 | assert!(JsonObjectText::new(r#"{"a":"๐","b":[-0.5e+3,true,false,null,{}]}"#).is_ok()); |
| 145 | } |
| 146 | |
| 147 | #[test] |
| 148 | fn test_nesting_past_the_limit_is_refused_00() { |
| 149 | let deep = fmt!("{{\"a\":{}1{}}}", "[".repeat(100_000), "]".repeat(100_000)); |
| 150 | assert!(JsonObjectText::new(&deep).is_err(), "a hundred thousand levels must be refused"); |
| 151 | } |
| 152 | |
| 153 | #[test] |
| 154 | fn test_get_str_decodes_a_top_level_string_00() { |
| 155 | let o = edit(r#"{"meta":{"note":"deep"},"note":"a\u000bb\"รฉ๐\/","n":1,"s":"plain"}"#); |
| 156 | assert_eq!(o.get_str("note"), Some(fmt!("a\u{0b}b\"\u{e9}\u{1f600}/"))); |
| 157 | assert_eq!(o.get_str("s"), Some(fmt!("plain"))); |
| 158 | // Not a string, or not a top-level member: nothing. |
| 159 | assert_eq!(o.get_str("n"), None); |
| 160 | assert_eq!(o.get_str("meta"), None); |
| 161 | assert_eq!(o.get_str("missing"), None); |
| 162 | } |
| 163 | |
| 164 | // โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ |
| 165 | // โ member: one member borrowed from the text โ |
| 166 | // โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ |
| 167 | |
| 168 | fn member_of<'a>(s: &'a str, key: &str) -> Outcome<Option<&'a str>> { |
| 169 | member(s, key, &DecodeLimits::text()) |
| 170 | } |
| 171 | |
| 172 | #[test] |
| 173 | fn test_member_found_past_a_large_member_written_first_00() -> Outcome<()> { |
| 174 | // The member sought comes after one whose strings hold braces, brackets, quotes, commas, |
| 175 | // colons and escapes, and whose nested objects name the same key. |
| 176 | let s = r#" { "chats": [{"t":"a } ] \" , \\", "mail":{"x":1}, "q":"}\"{"}, [[]], {}], |
| 177 | "mail" : {"sel":"m1","accounts":[{"id":"m1","pass":"p\"w}"}]} ,"z":null } "#; |
| 178 | assert_eq!(res!(member_of(s, "mail")), |
| 179 | Some(r#"{"sel":"m1","accounts":[{"id":"m1","pass":"p\"w}"}]}"#)); |
| 180 | assert_eq!(res!(member_of(s, "z")), Some("null")); |
| 181 | assert_eq!(res!(member_of(s, "t")), None); |
| 182 | assert_eq!(res!(member_of(s, "nope")), None); |
| 183 | // A value is borrowed from the text, never copied. |
| 184 | let v = match res!(member_of(s, "mail")) { |
| 185 | Some(v) => v, |
| 186 | None => return Err(err!("mail must be found"; Missing)), |
| 187 | }; |
| 188 | let off = v.as_ptr() as usize - s.as_ptr() as usize; |
| 189 | assert_eq!(&s[off..off + v.len()], v); |
| 190 | Ok(()) |
| 191 | } |
| 192 | |
| 193 | #[test] |
| 194 | fn test_member_scalars_and_order_00() -> Outcome<()> { |
| 195 | let s = r#"{"n":-1.5e3,"t":true,"s":"x","e":{}}"#; |
| 196 | assert_eq!(res!(member_of(s, "n")), Some("-1.5e3")); |
| 197 | assert_eq!(res!(member_of(s, "t")), Some("true")); |
| 198 | assert_eq!(res!(member_of(s, "s")), Some(r#""x""#)); |
| 199 | assert_eq!(res!(member_of(s, "e")), Some("{}")); |
| 200 | assert_eq!(res!(member_of("{}", "n")), None); |
| 201 | Ok(()) |
| 202 | } |
| 203 | |
| 204 | #[test] |
| 205 | fn test_member_found_by_its_unescaped_name_00() -> Outcome<()> { |
| 206 | let s = r#"{"mail":7,"q\"k":8}"#; |
| 207 | assert_eq!(res!(member_of(s, "mail")), Some("7")); |
| 208 | assert_eq!(res!(member_of(s, "q\"k")), Some("8")); |
| 209 | Ok(()) |
| 210 | } |
| 211 | |
| 212 | #[test] |
| 213 | fn test_member_refuses_what_is_not_one_object_00() -> Outcome<()> { |
| 214 | for bad in [ |
| 215 | r#"[1]"#, |
| 216 | r#"{"a":1"#, |
| 217 | r#"{"a":"x}"#, |
| 218 | r#"{"a":1,"a":2}"#, |
| 219 | r#"{"a":1} {}"#, |
| 220 | r#"{"a":"\q"}"#, |
| 221 | r#"{"a":}"#, |
| 222 | "", |
| 223 | ] { |
| 224 | assert!(member_of(bad, "a").is_err(), "{:?} must be refused", bad); |
| 225 | } |
| 226 | // The limits bound the length. |
| 227 | let lim = DecodeLimits::text().with_max_bytes(8); |
| 228 | assert!(member(r#"{"a":"123456"}"#, "a", &lim).is_err()); |
| 229 | Ok(()) |
| 230 | } |
| 231 | |
| 232 | #[test] |
| 233 | fn test_element_spans_lie_where_each_item_is_00() -> Outcome<()> { |
| 234 | // Escapes and a decoy of the same name elsewhere: the spans are the items of the value given, |
| 235 | // whatever the text around it holds. |
| 236 | let text = r#"{"meta":{"cells":[1,2]},"cells":[{"s":"],}"},{"t":"\\\""}, 3 ]}"#; |
| 237 | let o = edit(text); |
| 238 | let val = res!(o.members().iter().find(|m| m.key == "cells").map(|m| m.val.clone()) |
| 239 | .ok_or_else(|| err!("the object has no 'cells' member"; Bug))); |
| 240 | let spans = res!(element_spans(text, &val, &DecodeLimits::text())); |
| 241 | assert_eq!(spans.len(), 3); |
| 242 | let said: Vec<&str> = spans.iter().map(|s| &text[s.clone()]).collect(); |
| 243 | assert_eq!(said, vec![r#"{"s":"],}"}"#, r#"{"t":"\\\""}"#, "3"]); |
| 244 | // Splicing one item leaves every other byte as it was. |
| 245 | let mut cut = text.to_string(); |
| 246 | cut.replace_range(spans[1].clone(), r#"{"t":"x"}"#); |
| 247 | assert_eq!(cut, r#"{"meta":{"cells":[1,2]},"cells":[{"s":"],}"},{"t":"x"}, 3 ]}"#); |
| 248 | assert_eq!(res!(JsonObjectText::new(&cut)).keys(), vec![fmt!("meta"), fmt!("cells")]); |
| 249 | // An empty array has no items. |
| 250 | let e = "[]"; |
| 251 | assert_eq!(res!(element_spans(e, &(0..2), &DecodeLimits::text())).len(), 0); |
| 252 | // A span that is not an array, or not this text, is refused. |
| 253 | assert!(element_spans("{\"a\":1}", &(5..6), &DecodeLimits::text()).is_err()); |
| 254 | assert!(element_spans("[1,2]", &(0..4), &DecodeLimits::text()).is_err()); |
| 255 | assert!(element_spans("[1,2,]", &(0..6), &DecodeLimits::text()).is_err()); |
| 256 | Ok(()) |
| 257 | } |