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

280 lines
9.6 KiB
Rust

use base64::{Engine, engine::general_purpose::STANDARD};
use midra_layout::{
Geometry, Layout,
exchange::{self, Format, Options},
import::parse_values,
project::{Project, Resolution},
};
use std::io::Write;
fn fixture() -> Project {
let mut layout = Layout::default();
layout
.apply(
0,
Geometry {
x: -12.5,
y: 271.4,
width: 945.2,
height: 531.58,
},
)
.unwrap();
layout
.rename_layer(0, "Camera & <left> \"wide\"", "")
.unwrap();
Project::from_layout(&layout)
}
fn template(resolution: [u32; 2]) -> Project {
let mut project = Project::from_layout(&Layout::default());
let scale = resolution[0] as f64 / 1920.0;
project.output_resolution = Resolution::from(resolution);
for layer in &mut project.layers {
layer.bounds.x *= scale;
layer.bounds.y *= scale;
layer.bounds.width *= scale;
layer.bounds.height *= scale;
}
project
}
#[test]
fn readme_templates_match_the_exporter_and_contain_two_layers() {
for (resolution, svg, drawio) in [
(
[1920, 1080],
include_str!("../../../docs/templates/midra-layout/midra-layout-1080p-2-layers.svg"),
include_str!("../../../docs/templates/midra-layout/midra-layout-1080p-2-layers.drawio"),
),
(
[3840, 2160],
include_str!("../../../docs/templates/midra-layout/midra-layout-4k-2-layers.svg"),
include_str!("../../../docs/templates/midra-layout/midra-layout-4k-2-layers.drawio"),
),
] {
let project = template(resolution);
let ids = project
.layers
.iter()
.map(|layer| layer.id)
.collect::<Vec<_>>();
for (format, documented) in [(Format::Svg, svg), (Format::Drawio, drawio)] {
assert_eq!(
exchange::export(&project, &ids, format, Options::default()).unwrap(),
documented
);
let imported = parse_values(documented).unwrap();
assert_eq!(imported.shapes.len(), 2);
assert!(imported.shapes.iter().all(|shape| !shape.background_only));
assert_eq!(
imported
.shapes
.iter()
.map(|shape| shape.geometry)
.collect::<Vec<_>>(),
project
.layers
.iter()
.map(|layer| layer.bounds)
.collect::<Vec<_>>()
);
}
}
}
#[test]
fn every_format_and_artwork_option_roundtrips_geometry_and_order() {
let project = fixture();
let ids: Vec<_> = project.layers.iter().map(|l| l.id).collect();
for format in [Format::Svg, Format::Drawio] {
for background in [false, true] {
for placeholders in [false, true] {
let text = exchange::export(
&project,
&ids,
format,
Options {
background,
placeholders,
},
)
.unwrap();
let doc = parse_values(&text).unwrap();
assert_eq!(
doc.shapes.iter().filter(|s| s.background_only).count(),
usize::from(background)
);
let shapes: Vec<_> = doc.shapes.iter().filter(|s| !s.background_only).collect();
assert_eq!(shapes.len(), ids.len());
let mut imported = Layout::default();
let mappings: Vec<_> = shapes
.iter()
.enumerate()
.map(|(i, s)| {
let g = project.layers[i].bounds;
let expected = Geometry {
x: g.x.round(),
y: g.y.round(),
width: g.width.round(),
height: g.height.round(),
};
assert_eq!(s.geometry, expected);
assert_eq!(s.outline, [0.0, 0.0]);
(Some(imported.layer_info(i).id), s.geometry, None)
})
.collect();
imported.import_device_layers(&mappings).unwrap();
let reexport = exchange::export(
&Project::from_layout(&imported),
&ids,
format,
Options {
background,
placeholders,
},
)
.unwrap();
let reread = parse_values(&reexport).unwrap();
assert_eq!(
reread
.shapes
.iter()
.filter(|s| !s.background_only)
.map(|s| s.geometry)
.collect::<Vec<_>>(),
shapes.iter().map(|s| s.geometry).collect::<Vec<_>>()
);
}
}
}
}
#[test]
fn single_full_screen_layer_is_never_mistaken_for_background() {
let mut p = Project::from_layout(&Layout::default());
p.layers[0].bounds = Geometry {
x: 0.0,
y: 0.0,
width: 1920.0,
height: 1080.0,
};
for format in [Format::Svg, Format::Drawio] {
for placeholders in [false, true] {
let text = exchange::export(
&p,
&[p.layers[0].id],
format,
Options {
background: true,
placeholders,
},
)
.unwrap();
let doc = parse_values(&text).unwrap();
assert_eq!(doc.shapes.len(), 2);
assert!(doc.shapes[0].background_only);
assert!(!doc.shapes[1].background);
assert!(!doc.shapes[1].background_only);
}
}
}
#[test]
fn drawio_compressed_resave_and_percent_encoded_clipboard_are_supported() {
let p = fixture();
let xml = exchange::export(
&p,
&[p.layers[0].id],
Format::Drawio,
Options {
background: true,
placeholders: true,
},
)
.unwrap();
let doc = roxmltree::Document::parse(&xml).unwrap();
let model = doc
.descendants()
.find(|n| n.has_tag_name("mxGraphModel"))
.unwrap();
let model = &xml[model.range()];
let encoded = model
.bytes()
.map(|b| format!("%{b:02X}"))
.collect::<String>();
let mut encoder =
flate2::write::DeflateEncoder::new(Vec::new(), flate2::Compression::default());
encoder.write_all(encoded.as_bytes()).unwrap();
let compressed = STANDARD.encode(encoder.finish().unwrap());
let wrapped = format!("<mxfile><diagram>{compressed}</diagram></mxfile>");
for text in [&xml, &wrapped, &encoded] {
let shapes = parse_values(text).unwrap().shapes;
assert_eq!(shapes.len(), 2);
assert!(shapes[0].background_only);
assert_eq!(shapes[1].geometry.x, -13.0);
}
}
#[test]
fn reference_image_is_embedded_and_missing_ids_or_invalid_versions_fail() {
let mut p = fixture();
let mut png = std::io::Cursor::new(Vec::new());
image::RgbaImage::from_pixel(2, 2, image::Rgba([255, 0, 0, 255]))
.write_to(&mut png, image::ImageFormat::Png)
.unwrap();
p.reference = Some(midra_layout::project::Reference {
name: "red".into(),
image_base64: STANDARD.encode(png.into_inner()),
visible: true,
opacity: 1.0,
preserve_ratio: false,
native_size: false,
offset: [0.0, 0.0],
});
let xml = exchange::export(
&p,
&[p.layers[0].id],
Format::Svg,
Options {
background: true,
placeholders: false,
},
)
.unwrap();
let doc = roxmltree::Document::parse(&xml).unwrap();
let data = doc
.descendants()
.find(|n| n.has_tag_name("image"))
.unwrap()
.attribute(("http://www.w3.org/1999/xlink", "href"))
.unwrap();
let bytes = STANDARD
.decode(data.strip_prefix("data:image/png;base64,").unwrap())
.unwrap();
let image = image::load_from_memory(&bytes).unwrap().to_rgba8();
assert_eq!(*image.get_pixel(0, 0), image::Rgba([255, 0, 0, 255]));
assert!(parse_values(&xml.replace("geometry=\"2\"", "geometry=\"99\"")).is_err());
assert!(exchange::export(&p, &[], Format::Svg, Options::default()).is_err());
assert!(exchange::export(&p, &[999], Format::Drawio, Options::default()).is_err());
assert!(exchange::export(&p, &[1, 1], Format::Svg, Options::default()).is_err());
assert!(parse_values("<mxfile><diagram/><diagram/></mxfile>").is_err());
assert!(parse_values("<mxfile><diagram>garbage</diagram></mxfile>").is_err());
}
#[test]
fn documented_examples_import_and_limits_are_enforced() {
for text in [
include_str!("../../../docs/interfaces/midra-layout-svg-v2.example.svg"),
include_str!("../../../docs/interfaces/midra-layout-drawio-v1.example.drawio"),
] {
let doc = parse_values(text).unwrap();
assert_eq!(doc.shapes.len(), 2);
assert!(doc.shapes.iter().all(|s| !s.background_only));
}
assert!(
parse_values(&"x".repeat(exchange::MAX_EXCHANGE_BYTES + 1))
.unwrap_err()
.contains("16 MiB")
);
let mut p = fixture();
p.layers[0].bounds.width = 0.1;
assert!(exchange::export(&p, &[p.layers[0].id], Format::Svg, Options::default()).is_err());
}