332 lines
11 KiB
Rust
332 lines
11 KiB
Rust
use midra_layout::{
|
|
Geometry, Layout,
|
|
formats::{Crop, Framing, Source},
|
|
project::{Project, write_file},
|
|
};
|
|
|
|
#[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(),
|
|
Project::from_layout(&Layout::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(),
|
|
Project::from_layout(&Layout::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(),
|
|
Project::from_layout(&Layout::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, 6);
|
|
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, Project::from_layout(&Layout::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, 6);
|
|
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, 7] {
|
|
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());
|
|
}
|