Files
Marcos Paulo 00e96fe8c6 feat(whiteboard): wave 2 whiteboard
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-13 19:11:18 -03:00

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));
}