use midra_layout::{ Geometry, Layout, formats::{Crop, Framing, Source}, project::{Project, write_file}, }; // Old files retain their original labels/IDs rather than adopting new-project defaults. fn legacy_default() -> Project { let mut p = Project::from_layout(&Layout::default()); p.layers[0].id = 1; p.layers[0].name = "Presenter".into(); p.layers[1].id = 2; p.layers[1].name = "Slides".into(); p.editor.selected_layer_ids = vec![2]; p } #[test] fn full_precision_project_roundtrip_restores_sources_crops_flags_and_selection() { let mut layout = Layout::default(); let g = Geometry { x: -12.123456789, y: 371.23456789, width: 300.125, height: 250.25, }; let source = Source { input_crop: Crop { top: 40.0, bottom: 40.0, ..Crop::default() }, ..Source::default() }; layout.configure(1, 0, source, g, true).unwrap(); layout .set_framing( 1, Framing { zoom: 2.25, offset: [10.0, -15.0], }, ) .unwrap(); layout.set_visible(0, false); layout.set_locked(0, true); layout.set_output([2560, 1600]).unwrap(); let project = Project::from_layout(&layout); let json = project.to_json().unwrap(); assert!(json.contains("\"advanced_crop\"")); let decoded = Project::from_json(&json).unwrap(); assert_eq!(decoded, project); let mut loaded = decoded.layout().unwrap(); assert_eq!(loaded.layers(), layout.layers()); assert_eq!(loaded.formats(), layout.formats()); assert!(loaded.locked(0)); assert!(!loaded.visible(0)); assert_eq!(loaded.selection_mask(), layout.selection_mask()); loaded.undo(); assert_eq!(loaded.layers(), layout.layers()); } #[test] fn malformed_or_incompatible_projects_are_refused() { let original = serde_json::to_value(Project::from_layout(&Layout::default())).unwrap(); for (pointer, value) in [ ("/version", serde_json::json!(999)), ("/format", serde_json::json!("other")), ("/layers/0/source_id", serde_json::json!(0)), ("/inputs/1/id", serde_json::json!(1)), ("/layers/0/bounds/width", serde_json::json!(-1)), ("/layers/1/advanced_crop/left", serde_json::json!(1900)), ("/editor/selected_layer_ids", serde_json::json!([2, 2])), ("/layers/1/locked", serde_json::json!(true)), ("/editor/viewport_zoom", serde_json::json!(0)), ("/inputs/0/native_resolution/width", serde_json::json!(0)), ] { let mut invalid = original.clone(); *invalid.pointer_mut(pointer).unwrap() = value; assert!( Project::from_json(&invalid.to_string()).is_err(), "{pointer}" ); } let mut extra = original.clone(); extra["unexpected"] = serde_json::json!(true); assert!(Project::from_json(&extra.to_string()).is_err()); let mut missing = original.clone(); missing.as_object_mut().unwrap().remove("version"); assert!(Project::from_json(&missing.to_string()).is_err()); assert!(Project::from_json("{broken").is_err()); } #[test] fn exported_svg_roundtrips_rounded_geometry_including_full_screen_layers() { let mut layout = Layout::default(); layout .apply( 0, Geometry { x: 0.0, y: 0.0, width: 1920.0, height: 1080.0, }, ) .unwrap(); layout .apply( 1, Geometry { x: -12.6, y: 27.4, width: 300.8, height: 250.2, }, ) .unwrap(); layout.set_visible(1, false); let p = Project::from_layout(&layout); let doc = midra_layout::import::parse_svg(&p.to_svg(false).unwrap()).unwrap(); assert_eq!(doc.shapes.len(), 2); assert!(!doc.shapes[0].background); assert_eq!(doc.shapes[0].geometry, layout.layers()[0]); assert_eq!( doc.shapes[1].geometry, Geometry { x: -13.0, y: 27.0, width: 301.0, height: 250.0 } ); assert_eq!(doc.shapes[1].outline, [0.0; 2]); assert_eq!( midra_layout::import::parse_svg(&p.to_svg(true).unwrap()) .unwrap() .shapes .len(), 1 ); layout.set_visible(0, false); assert!(Project::from_layout(&layout).to_svg(true).is_err()); } #[test] fn publication_requires_overwrite_and_read_matches_written_document() { let dir = tempfile::tempdir().unwrap(); let path = dir.path().join("layout.midra.json"); let p = Project::from_layout(&Layout::default()); write_file(&path, p.to_json().unwrap().as_bytes(), false).unwrap(); assert_eq!(Project::read(&path).unwrap(), p); assert!(write_file(&path, b"replacement", false).is_err()); assert_eq!(Project::read(&path).unwrap(), p); write_file(&path, b"replacement", true).unwrap(); assert_eq!(std::fs::read(&path).unwrap(), b"replacement"); assert_eq!(std::fs::read_dir(dir.path()).unwrap().count(), 1); } #[test] fn documented_example_is_a_valid_version_one_project() { let example = include_str!("../../../docs/interfaces/midra-layout-v1.example.json"); assert_eq!(Project::from_json(example).unwrap(), legacy_default()); } #[test] fn version_two_requires_captions_preference_and_preserves_it() { let mut project = Project::from_layout(&Layout::default()); project.editor.show_toolbar_icon_names = true; assert_eq!( Project::from_json(&project.to_json().unwrap()).unwrap(), project ); let mut missing = serde_json::to_value(&project).unwrap(); missing["editor"] .as_object_mut() .unwrap() .remove("show_toolbar_icon_names"); assert!(Project::from_json(&missing.to_string()).is_err()); let example = include_str!("../../../docs/interfaces/midra-layout-v2.example.json"); assert_eq!(Project::from_json(example).unwrap(), legacy_default()); } #[test] fn v4_example_and_old_version_migrations_preserve_defaults() { assert_eq!( Project::from_json(include_str!( "../../../docs/interfaces/midra-layout-v4.example.json" )) .unwrap(), legacy_default() ); let mut value = serde_json::to_value(Project::from_layout(&Layout::default())).unwrap(); value["version"] = 0.into(); assert!(Project::from_json(&value.to_string()).is_err()); value["version"] = 4.into(); value["editor"] .as_object_mut() .unwrap() .remove("outline_layers"); assert!(Project::from_json(&value.to_string()).is_err()); } #[test] fn persistent_midra_links_roundtrip_migrate_and_undo() { use midra_layout::MidraLink; let mut layout = Layout::default(); let link = MidraLink { screen: "2".into(), layer: "1".into(), }; let first_link = MidraLink { screen: "1".into(), layer: "1".into(), }; layout.set_midra_link(0, Some(first_link.clone())).unwrap(); layout.set_midra_link(1, Some(link.clone())).unwrap(); layout.select(None); let project = Project::from_layout(&layout); let restored = Project::from_json(&project.to_json().unwrap()) .unwrap() .layout() .unwrap(); assert_eq!(restored.layer_info(0).midra_link, Some(first_link)); assert_eq!(restored.layer_info(1).midra_link, Some(link.clone())); layout.undo(); assert!(layout.layer_info(1).midra_link.is_none()); layout.redo(); assert_eq!(layout.layer_info(1).midra_link, Some(link)); layout.set_midra_link(1, None).unwrap(); assert!(layout.layer_info(1).midra_link.is_none()); for text in [ include_str!("../../../docs/interfaces/midra-layout-v4.example.json"), include_str!("../../../docs/interfaces/midra-layout-v5.example.json"), ] { let p = Project::from_json(text).unwrap(); assert_eq!(p.version, 12); assert!(p.layers.iter().all(|l| l.midra_link.is_none())); } let mut value = serde_json::to_value(&project).unwrap(); value["layers"][1]["midra_link"]["screen"] = "../2".into(); assert!(Project::from_json(&value.to_string()).is_err()); value["layers"][1]["midra_link"] = serde_json::Value::Null; value["layers"][1] .as_object_mut() .unwrap() .remove("midra_link"); assert!(Project::from_json(&value.to_string()).is_err()); } #[test] fn positioning_points_roundtrip_and_keep_their_reference_when_resized() { use midra_layout::PositionPoint; let output = [1921, 1081]; let g = Geometry { x: 100.25, y: 200.5, width: 321.5, height: 181.25, }; for point in [ PositionPoint::TopLeft, PositionPoint::TopRight, PositionPoint::BottomLeft, PositionPoint::BottomRight, PositionPoint::Center, ] { let [dx, dy] = point.offsets_on(g, output); assert_eq!( point .geometry_on(dx, dy, g.width, g.height, output) .unwrap(), g ); let resized = point.geometry_on(dx, dy, 123.5, 99.25, output).unwrap(); assert_eq!(point.offsets_on(resized, output), [dx, dy]); if point == PositionPoint::Center { assert!(dx < 0.0 && dy < 0.0); assert_eq!(resized.center(), g.center()); } let mut project = Project::from_layout(&Layout::default()); project.editor.position_point = point; assert_eq!( Project::from_json(&project.to_json().unwrap()).unwrap(), project ); } let centered = PositionPoint::Center .geometry_on(0.0, 0.0, 320.0, 180.0, output) .unwrap(); assert_eq!(centered.center(), [960.5, 540.5]); } #[test] fn position_point_schema_migrates_corners_and_rejects_mislabeled_files() { use midra_layout::PositionPoint; let current = Project::from_json(include_str!( "../../../docs/interfaces/midra-layout-v6.example.json" )) .unwrap(); assert_eq!(current, legacy_default()); for (name, expected) in [ ("top_left", PositionPoint::TopLeft), ("top_right", PositionPoint::TopRight), ("bottom_left", PositionPoint::BottomLeft), ("bottom_right", PositionPoint::BottomRight), ] { let mut old: serde_json::Value = serde_json::from_str(include_str!( "../../../docs/interfaces/midra-layout-v5.example.json" )) .unwrap(); old["editor"]["position_corner"] = name.into(); let loaded = Project::from_json(&old.to_string()).unwrap(); assert_eq!(loaded.version, 12); assert_eq!(loaded.editor.position_point, expected); old["editor"]["position_corner"] = "center".into(); assert!(Project::from_json(&old.to_string()).is_err()); old["editor"]["position_corner"] = name.into(); old["editor"]["position_point"] = name.into(); assert!(Project::from_json(&old.to_string()).is_err()); } let value: serde_json::Value = serde_json::from_str(¤t.to_json().unwrap()).unwrap(); for version in [0, 13] { let mut invalid = value.clone(); invalid["version"] = version.into(); assert!( Project::from_json(&invalid.to_string()) .unwrap_err() .contains("Unsupported") ); } let mut invalid = value.clone(); invalid["editor"] .as_object_mut() .unwrap() .remove("position_point"); assert!(Project::from_json(&invalid.to_string()).is_err()); invalid["editor"]["position_corner"] = "top_left".into(); assert!(Project::from_json(&invalid.to_string()).is_err()); } #[test] fn backdrop_title_roundtrips_and_older_projects_gain_the_default() { use midra_layout::project::DEFAULT_BACKDROP_TITLE; let current = Project::from_json(include_str!( "../../../docs/interfaces/midra-layout-v7.example.json" )) .unwrap(); assert_eq!(current, legacy_default()); for text in ["", "Conférence · Main stage", &"é".repeat(128)] { let mut project = current.clone(); project.editor.backdrop_title = text.into(); assert_eq!( Project::from_json(&project.to_json().unwrap()).unwrap(), project ); assert_eq!( project.to_svg(false).unwrap(), current.to_svg(false).unwrap() ); } let old = include_str!("../../../docs/interfaces/midra-layout-v6.example.json"); let migrated = Project::from_json(old).unwrap(); assert_eq!(migrated.version, 12); assert_eq!(migrated.editor.backdrop_title, DEFAULT_BACKDROP_TITLE); let mut invalid: serde_json::Value = serde_json::from_str(old).unwrap(); invalid["editor"]["backdrop_title"] = "Unexpected".into(); assert!(Project::from_json(&invalid.to_string()).is_err()); let value: serde_json::Value = serde_json::from_str(¤t.to_json().unwrap()).unwrap(); for title in ["a".repeat(129), "line\nbreak".into(), "tab\there".into()] { let mut invalid = value.clone(); invalid["editor"]["backdrop_title"] = title.into(); assert!(Project::from_json(&invalid.to_string()).is_err()); } let mut missing = value; missing["editor"] .as_object_mut() .unwrap() .remove("backdrop_title"); assert!(Project::from_json(&missing.to_string()).is_err()); } #[test] fn independent_layer_point_is_explicit_and_old_projects_keep_matched_points() { use midra_layout::PositionPoint; let current = Project::from_json(include_str!( "../../../docs/interfaces/midra-layout-v8.example.json" )) .unwrap(); assert_eq!(current, legacy_default()); for point in [ None, Some(PositionPoint::Center), Some(PositionPoint::BottomRight), ] { let mut project = current.clone(); project.editor.position_layer_point = point; assert_eq!( Project::from_json(&project.to_json().unwrap()).unwrap(), project ); } let old = include_str!("../../../docs/interfaces/midra-layout-v7.example.json"); assert!( Project::from_json(old) .unwrap() .editor .position_layer_point .is_none() ); let mut invalid: serde_json::Value = serde_json::from_str(old).unwrap(); invalid["editor"]["position_layer_point"] = "center".into(); assert!(Project::from_json(&invalid.to_string()).is_err()); let mut missing: serde_json::Value = serde_json::from_str(¤t.to_json().unwrap()).unwrap(); missing["editor"] .as_object_mut() .unwrap() .remove("position_layer_point"); assert!(Project::from_json(&missing.to_string()).is_err()); } #[test] fn saved_pivots_roundtrip_and_old_projects_default_to_center() { let mut layout = Layout::default(); let custom = [-0.123456789, 1.25]; layout.set_layer_pivots(&[(0, custom)]).unwrap(); let project = Project::from_layout(&layout); let loaded = Project::from_json(&project.to_json().unwrap()) .unwrap() .layout() .unwrap(); assert_eq!(loaded.layer_info(0).pivot, custom); assert_eq!(loaded.layer_info(1).pivot, [0.5; 2]); let example = include_str!("../../../docs/interfaces/midra-layout-v9.example.json"); assert_eq!(Project::from_json(example).unwrap().version, 12); let old = include_str!("../../../docs/interfaces/midra-layout-v8.example.json"); let migrated = Project::from_json(old).unwrap(); assert!(migrated.layers.iter().all(|l| l.pivot == [0.5; 2])); let mut old: serde_json::Value = serde_json::from_str(old).unwrap(); old["layers"][0]["pivot"] = serde_json::json!([0.2, 0.3]); assert!(Project::from_json(&old.to_string()).is_err()); for invalid in [ serde_json::json!([1e7, 0.5]), serde_json::json!([0.5]), serde_json::json!([0.5, 0.5, 0.5]), serde_json::Value::Null, ] { let mut value = serde_json::to_value(&project).unwrap(); value["layers"][0]["pivot"] = invalid; assert!(Project::from_json(&value.to_string()).is_err()); } let mut value = serde_json::to_value(&project).unwrap(); value["layers"][0].as_object_mut().unwrap().remove("pivot"); assert!(Project::from_json(&value.to_string()).is_err()); } #[test] fn reference_collection_migrates_single_images_and_rejects_mislabeled_or_oversized_collections() { use base64::{Engine, engine::general_purpose::STANDARD}; let mut old: serde_json::Value = serde_json::from_str(include_str!( "../../../docs/interfaces/midra-layout-v9.example.json" )) .unwrap(); let reference = serde_json::json!({"name":"guide.png","image_base64":STANDARD.encode(b"image bytes"),"visible":false,"opacity":0.4,"preserve_ratio":true,"native_size":false,"offset":[0.0,0.0]}); old["reference"] = reference.clone(); let migrated = Project::from_json(&old.to_string()).unwrap(); assert_eq!(migrated.version, 12); assert_eq!(migrated.references.len(), 1); assert!(!migrated.references[0].visible); assert_eq!(migrated.references[0].opacity, 0.4); let mut gallery = migrated.clone(); gallery.references.push(migrated.references[0].clone()); gallery.references[1].name = "other.png".into(); gallery.references[1].visible = true; assert_eq!( Project::from_json(&gallery.to_json().unwrap()).unwrap(), gallery ); old["references"] = serde_json::json!([]); assert!(Project::from_json(&old.to_string()).is_err()); let mut wrong = serde_json::to_value(&gallery).unwrap(); wrong["reference"] = reference; assert!(Project::from_json(&wrong.to_string()).is_err()); gallery.references = vec![migrated.references[0].clone(); 33]; assert!(gallery.to_json().unwrap_err().contains("32 reference")); let example = include_str!("../../../docs/interfaces/midra-layout-v10.example.json"); assert_eq!(Project::from_json(example).unwrap().version, 12); } #[test] fn editor_inputs_grow_independently_and_roundtrip_with_undo() { let mut layout = Layout::default(); let before = layout.formats().clone(); let geometry = layout.layers()[0]; layout .configure(0, 7, Source::default(), geometry, true) .unwrap(); assert_eq!(layout.layers().len(), 2); assert_eq!(layout.formats().sources.len(), 8); assert_eq!(layout.formats().source_for, [7, 1]); layout.undo(); assert_eq!(layout.formats(), &before); layout.redo(); layout .configure(1, 7, Source::default(), layout.layers()[1], true) .unwrap(); let project = Project::from_layout(&layout); let restored = Project::from_json(&project.to_json().unwrap()) .unwrap() .layout() .unwrap(); assert_eq!(restored.formats(), layout.formats()); assert_eq!(project.inputs.len(), 8); assert_eq!(project.layers[0].source_id, 8); layout .configure(0, 8, Source::default(), geometry, true) .unwrap(); assert_eq!(layout.formats().sources.len(), 9); let before = layout.formats().clone(); assert!( layout .configure(0, 1024, Source::default(), geometry, true) .is_err() ); assert_eq!(layout.formats(), &before); layout.set_locked(0, true); assert!( layout .configure(0, 9, Source::default(), geometry, true) .is_err() ); assert_eq!(layout.formats(), &before); } #[test] fn workspace_roundtrip_migration_and_validation() { use midra_layout::project::{Preview, Workspace}; let old = include_str!("../../../docs/interfaces/midra-layout-v10.example.json"); let migrated = Project::from_json(old).unwrap(); assert_eq!(migrated.workspace, Workspace::default()); let current = include_str!("../../../docs/interfaces/midra-layout-v11.example.json"); assert_eq!(Project::from_json(current).unwrap(), migrated); let mut p = Project::from_layout(&Layout::default()); p.layers[0].folder = "Memory A".into(); p.workspace.collapsed_folders = vec!["Memory A".into()]; p.workspace.resize_mode = midra_layout::ResizeMode::Opposite; p.workspace.grid_spacing = Some(100); p.workspace.snapping.grid_divisions = [13, 7]; p.workspace.snapping.enabled = true; p.workspace.capture_interval_seconds = 37; p.workspace.show_empty_inputs = true; p.workspace.previews.push(Preview { layer_id: p.layers[0].id, source_id: p.layers[0].source_id, input: 8, host: "192.168.10.146:3000".into(), enabled: true, automatic: true, guide_opacity: 0.27, name: "Input 8".into(), image_base64: String::new(), }); assert_eq!(Project::from_json(&p.to_json().unwrap()).unwrap(), p); let good = serde_json::to_value(&p).unwrap(); for (path, value) in [ ("/workspace/capture_interval_seconds", serde_json::json!(0)), ("/workspace/grid_spacing", serde_json::json!(0)), ( "/workspace/snapping/grid_divisions/0", serde_json::json!(65), ), ("/workspace/resize_mode", serde_json::json!("unknown")), ( "/workspace/collapsed_folders/0", serde_json::json!("missing"), ), ("/workspace/previews/0/layer_id", serde_json::json!(999)), ("/workspace/previews/0/source_id", serde_json::json!(999)), ("/workspace/previews/0/input", serde_json::json!(1025)), ( "/workspace/previews/0/host", serde_json::json!("https://example.org/"), ), ( "/workspace/previews/0/guide_opacity", serde_json::json!(1.1), ), ( "/workspace/previews/0/image_base64", serde_json::json!("!bad"), ), ] { let mut bad = good.clone(); *bad.pointer_mut(path).unwrap() = value; assert!(Project::from_json(&bad.to_string()).is_err(), "{path}"); } let mut bad = p.clone(); bad.workspace .previews .push(bad.workspace.previews[0].clone()); assert!(bad.to_json().is_err()); let mut old: serde_json::Value = serde_json::from_str(old).unwrap(); old["workspace"] = good["workspace"].clone(); assert!(Project::from_json(&old.to_string()).is_err()); let mut missing = good.clone(); missing.as_object_mut().unwrap().remove("workspace"); assert!(Project::from_json(&missing.to_string()).is_err()); }