223 lines
7.6 KiB
Rust
223 lines
7.6 KiB
Rust
use base64::{Engine, engine::general_purpose::STANDARD};
|
|
use midra_layout::{
|
|
Geometry, Layout,
|
|
exchange::{self, Format, Options},
|
|
import::parse_values,
|
|
project::Project,
|
|
};
|
|
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)
|
|
}
|
|
#[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());
|
|
}
|