beffroi-tools/crates/midra-layout/tests/project.rs

452 lines
16 KiB
Rust

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, 9);
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, 9);
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(&current.to_json().unwrap()).unwrap();
for version in [0, 10] {
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, 9);
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(&current.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(&current.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, 9);
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());
}