00e96fe8c6
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
228 lines
9.0 KiB
Rust
228 lines
9.0 KiB
Rust
//! Round-trip and unknown-field preservation over hand-written Excalidraw files.
|
|
|
|
use notescraft_whiteboard::{Element, ElementKind, Whiteboard};
|
|
|
|
const ALL_TYPES: &str = include_str!("fixtures/all_types.excalidraw.json");
|
|
const BOUND_ARROW: &str = include_str!("fixtures/bound_arrow.excalidraw.json");
|
|
const TEXT_CONTAINER: &str = include_str!("fixtures/text_container.excalidraw.json");
|
|
const IMAGE_FILES: &str = include_str!("fixtures/image_with_files.excalidraw.json");
|
|
const UNKNOWNS: &str = include_str!("fixtures/unknowns.excalidraw.json");
|
|
const MINIMAL: &str = include_str!("fixtures/minimal.excalidraw.json");
|
|
|
|
fn all() -> [&'static str; 6] {
|
|
[ALL_TYPES, BOUND_ARROW, TEXT_CONTAINER, IMAGE_FILES, UNKNOWNS, MINIMAL]
|
|
}
|
|
|
|
/// `read(write(read(x))) == read(x)` and the canonical header is always written.
|
|
#[test]
|
|
fn round_trip_is_stable() {
|
|
for source in all() {
|
|
let board = Whiteboard::from_str(source).expect("fixture parses");
|
|
let json = board.to_string_pretty().expect("serializes");
|
|
let again = Whiteboard::from_str(&json).expect("canonical output parses");
|
|
assert_eq!(board, again, "model changed after a round trip");
|
|
let json2 = again.to_string_pretty().expect("serializes again");
|
|
assert_eq!(json, json2, "canonical output is not idempotent");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn canonical_header_is_written() {
|
|
for source in all() {
|
|
let json = Whiteboard::from_str(source).expect("fixture parses").to_string_pretty().expect("serializes");
|
|
let parsed: serde_json::Value = serde_json::from_str(&json).expect("valid json");
|
|
assert_eq!(parsed.get("type").and_then(serde_json::Value::as_str), Some("excalidraw"));
|
|
assert_eq!(parsed.get("version").and_then(serde_json::Value::as_u64), Some(2));
|
|
assert!(parsed.get("elements").and_then(serde_json::Value::as_array).is_some());
|
|
}
|
|
}
|
|
|
|
/// Every unknown key of the fixture, at every level, survives a round trip.
|
|
#[test]
|
|
fn unknown_fields_are_preserved() {
|
|
let board = Whiteboard::from_str(UNKNOWNS).expect("fixture parses");
|
|
let json = board.to_string_pretty().expect("serializes");
|
|
for key in [
|
|
"appVersion",
|
|
"exportedFrom",
|
|
"unknownTopLevelKey",
|
|
"customKind",
|
|
"url",
|
|
"customData",
|
|
"frameId",
|
|
"boundText",
|
|
"roundness",
|
|
"unknownBindingField",
|
|
"elbowed",
|
|
"unknownArrowFlag",
|
|
"unknownFreedrawField",
|
|
"extra",
|
|
"unknownAppStateKey",
|
|
] {
|
|
assert!(json.contains(key), "unknown key `{key}` was dropped:\n{json}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn unknown_element_type_keeps_every_field() {
|
|
let board = Whiteboard::from_str(UNKNOWNS).expect("fixture parses");
|
|
let element = board.element("custom-1").expect("element present");
|
|
assert_eq!(element.type_name(), "embeddable");
|
|
assert!(matches!(&element.kind, ElementKind::Unknown { type_name } if type_name == "embeddable"), "unknown element type must map to ElementKind::Unknown");
|
|
let json = serde_json::to_value(element).expect("serializes");
|
|
let object = json.as_object().expect("object");
|
|
assert_eq!(object.get("type").and_then(serde_json::Value::as_str), Some("embeddable"));
|
|
assert_eq!(object.get("customKind").and_then(serde_json::Value::as_str), Some("iframe"));
|
|
}
|
|
|
|
/// Common fields and kind payloads survive the trip.
|
|
#[test]
|
|
fn all_element_types_are_parsed() {
|
|
let board = Whiteboard::from_str(ALL_TYPES).expect("fixture parses");
|
|
assert_eq!(board.elements.len(), 9);
|
|
assert_eq!(
|
|
board.elements.iter().map(Element::type_name).collect::<Vec<_>>(),
|
|
["rectangle", "ellipse", "diamond", "line", "arrow", "freedraw", "text", "image", "frame"]
|
|
);
|
|
|
|
let arrow = board.element("arrow-0001").expect("arrow present");
|
|
let ElementKind::Arrow { points, end_arrowhead, .. } = &arrow.kind else {
|
|
panic!("arrow kind");
|
|
};
|
|
assert_eq!(points.len(), 3);
|
|
assert_eq!(points[0], [0.0, 0.0]);
|
|
assert_eq!(points[2][0], -100.0);
|
|
assert_eq!(end_arrowhead.as_deref(), Some("arrow"));
|
|
|
|
let free = board.element("freedraw-0001").expect("freedraw present");
|
|
let ElementKind::Freedraw { points, pressures } = &free.kind else {
|
|
panic!("freedraw kind");
|
|
};
|
|
assert_eq!(points.len(), 5);
|
|
assert_eq!(pressures.len(), 5);
|
|
|
|
let text = board.element("text-0001").expect("text present");
|
|
let ElementKind::Text { text: body, font_family, container_id, .. } = &text.kind else {
|
|
panic!("text kind");
|
|
};
|
|
assert_eq!(body, "Hello whiteboard");
|
|
assert_eq!(font_family, "1");
|
|
assert!(container_id.is_none());
|
|
|
|
let image = board.element("image-0001").expect("image present");
|
|
let ElementKind::Image { file_id } = &image.kind else {
|
|
panic!("image kind");
|
|
};
|
|
assert_eq!(file_id, "file-abc");
|
|
|
|
let frame = board.element("frame-0001").expect("frame present");
|
|
let ElementKind::Frame { name } = &frame.kind else {
|
|
panic!("frame kind");
|
|
};
|
|
assert_eq!(name, "Board 1");
|
|
|
|
let rect = board.element("rect-0001").expect("rect present");
|
|
assert_eq!(rect.group_ids, ["grp-1"]);
|
|
assert_eq!(rect.bound_elements.len(), 1);
|
|
assert_eq!(rect.bound_elements[0].id, "arrow-0001");
|
|
assert_eq!(rect.bound_elements[0].type_name, "arrow");
|
|
assert_eq!(rect.link.as_deref(), Some("note://diagram"));
|
|
assert_eq!(rect.stroke_width, 2.0);
|
|
}
|
|
|
|
#[test]
|
|
fn bound_arrow_keeps_bindings() {
|
|
let board = Whiteboard::from_str(BOUND_ARROW).expect("fixture parses");
|
|
let arrow = board.element("link").expect("arrow present");
|
|
let ElementKind::Arrow { start_binding, end_binding, .. } = &arrow.kind else {
|
|
panic!("arrow kind");
|
|
};
|
|
let start = start_binding.as_ref().expect("start binding");
|
|
let end = end_binding.as_ref().expect("end binding");
|
|
assert_eq!(start.element_id, "src");
|
|
assert_eq!(start.gap, Some(4.0));
|
|
assert_eq!(end.element_id, "dst");
|
|
assert_eq!(end.focus, Some(-0.2));
|
|
|
|
let json = board.to_string_pretty().expect("serializes");
|
|
assert!(json.contains("\"elementId\""), "binding keys must stay camelCase:\n{json}");
|
|
assert!(json.contains("\"boundElements\""), "bound elements must survive:\n{json}");
|
|
}
|
|
|
|
#[test]
|
|
fn text_in_container_is_parsed() {
|
|
let board = Whiteboard::from_str(TEXT_CONTAINER).expect("fixture parses");
|
|
let caption = board.element("caption-1").expect("text present");
|
|
let ElementKind::Text { container_id, text_align, vertical_align, .. } = &caption.kind else {
|
|
panic!("text kind");
|
|
};
|
|
assert_eq!(container_id.as_deref(), Some("container-1"));
|
|
assert_eq!(text_align, "center");
|
|
assert_eq!(vertical_align, "middle");
|
|
assert_eq!(caption.bound_elements.len(), 0);
|
|
}
|
|
|
|
/// `files` is kept as an opaque JSON value, image elements keep their `fileId`.
|
|
#[test]
|
|
fn files_are_kept_verbatim() {
|
|
let board = Whiteboard::from_str(IMAGE_FILES).expect("fixture parses");
|
|
assert_eq!(board.files.get("6a1b2c3d4e5f60718293a4b5c6d7e8f9").and_then(|f| f.get("mimeType")).and_then(serde_json::Value::as_str), Some("image/png"));
|
|
let json = board.to_string_pretty().expect("serializes");
|
|
assert!(json.contains("dataURL"), "file payload must survive:\n{json}");
|
|
assert!(json.contains("\"fileId\""), "images keep fileId:\n{json}");
|
|
}
|
|
|
|
#[test]
|
|
fn missing_optional_fields_get_defaults() {
|
|
let board = Whiteboard::from_str(MINIMAL).expect("fixture parses");
|
|
let rect = board.element("bare-rect").expect("element present");
|
|
assert_eq!(rect.x, 0.0);
|
|
assert_eq!(rect.width, 0.0);
|
|
assert_eq!(rect.roughness, 1);
|
|
assert!(!rect.is_deleted);
|
|
assert_eq!(rect.group_ids, Vec::<String>::new());
|
|
assert!(board.app_state.as_object().is_some_and(serde_json::Map::is_empty));
|
|
assert!(board.files.as_object().is_some_and(serde_json::Map::is_empty));
|
|
assert!(board.extra.is_empty());
|
|
let json = board.to_string_pretty().expect("serializes");
|
|
assert!(json.contains("\"appState\""), "appState is always emitted:\n{json}");
|
|
assert!(json.contains("\"files\""), "files is always emitted:\n{json}");
|
|
}
|
|
|
|
/// Element JSON also goes through plain serde, not only the whiteboard wrapper.
|
|
#[test]
|
|
fn element_json_is_camel_case() {
|
|
let source = r##"{"id":"x","type":"rectangle","isDeleted":true,"strokeColor":"#fff","versionNonce":7,"boundElements":[]}"##;
|
|
let element: Element = serde_json::from_str(source).expect("parses");
|
|
let back = serde_json::to_value(&element).expect("serializes");
|
|
let object = back.as_object().expect("object");
|
|
for key in [
|
|
"id",
|
|
"type",
|
|
"isDeleted",
|
|
"strokeColor",
|
|
"versionNonce",
|
|
"boundElements",
|
|
"x",
|
|
"y",
|
|
"width",
|
|
"height",
|
|
"angle",
|
|
"opacity",
|
|
"seed",
|
|
"roughness",
|
|
"updated",
|
|
"fillStyle",
|
|
"strokeWidth",
|
|
"strokeStyle",
|
|
"groupIds",
|
|
"locked",
|
|
"link",
|
|
"version",
|
|
"backgroundColor",
|
|
] {
|
|
assert!(object.contains_key(key), "missing canonical key `{key}`");
|
|
}
|
|
assert_eq!(object.get("isDeleted").and_then(serde_json::Value::as_bool), Some(true));
|
|
}
|