607 lines
22 KiB
Rust
607 lines
22 KiB
Rust
use canvas_pilot::{
|
|
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 = canvas_pilot::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!(
|
|
canvas_pilot::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/canvas-pilot-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/canvas-pilot-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/canvas-pilot-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_device_links_roundtrip_migrate_and_undo() {
|
|
use canvas_pilot::DeviceLink;
|
|
let mut layout = Layout::default();
|
|
let link = DeviceLink {
|
|
family: Default::default(),
|
|
screen: "2".into(),
|
|
layer: "1".into(),
|
|
};
|
|
let first_link = DeviceLink {
|
|
family: Default::default(),
|
|
screen: "1".into(),
|
|
layer: "1".into(),
|
|
};
|
|
layout.set_device_link(0, Some(first_link.clone())).unwrap();
|
|
layout.set_device_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).device_link, Some(first_link));
|
|
assert_eq!(restored.layer_info(1).device_link, Some(link.clone()));
|
|
layout.undo();
|
|
assert!(layout.layer_info(1).device_link.is_none());
|
|
layout.redo();
|
|
assert_eq!(layout.layer_info(1).device_link, Some(link));
|
|
layout.set_device_link(1, None).unwrap();
|
|
assert!(layout.layer_info(1).device_link.is_none());
|
|
for text in [
|
|
include_str!("../../../docs/interfaces/canvas-pilot-v4.example.json"),
|
|
include_str!("../../../docs/interfaces/canvas-pilot-v5.example.json"),
|
|
] {
|
|
let p = Project::from_json(text).unwrap();
|
|
assert_eq!(p.version, 15);
|
|
assert!(p.layers.iter().all(|l| l.device_link.is_none()));
|
|
}
|
|
let mut value = serde_json::to_value(&project).unwrap();
|
|
value["layers"][1]["device_link"]["screen"] = "../2".into();
|
|
assert!(Project::from_json(&value.to_string()).is_err());
|
|
value["layers"][1]["device_link"] = serde_json::Value::Null;
|
|
value["layers"][1]
|
|
.as_object_mut()
|
|
.unwrap()
|
|
.remove("device_link");
|
|
assert!(Project::from_json(&value.to_string()).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn positioning_points_roundtrip_and_keep_their_reference_when_resized() {
|
|
use canvas_pilot::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 canvas_pilot::PositionPoint;
|
|
let current = Project::from_json(include_str!(
|
|
"../../../docs/interfaces/canvas-pilot-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/canvas-pilot-v5.example.json"
|
|
))
|
|
.unwrap();
|
|
old["editor"]["position_corner"] = name.into();
|
|
let loaded = Project::from_json(&old.to_string()).unwrap();
|
|
assert_eq!(loaded.version, 15);
|
|
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, 16] {
|
|
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 canvas_pilot::project::DEFAULT_BACKDROP_TITLE;
|
|
let current = Project::from_json(include_str!(
|
|
"../../../docs/interfaces/canvas-pilot-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/canvas-pilot-v6.example.json");
|
|
let migrated = Project::from_json(old).unwrap();
|
|
assert_eq!(migrated.version, 15);
|
|
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 canvas_pilot::PositionPoint;
|
|
let current = Project::from_json(include_str!(
|
|
"../../../docs/interfaces/canvas-pilot-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/canvas-pilot-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/canvas-pilot-v9.example.json");
|
|
assert_eq!(Project::from_json(example).unwrap().version, 15);
|
|
let old = include_str!("../../../docs/interfaces/canvas-pilot-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/canvas-pilot-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, 15);
|
|
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/canvas-pilot-v10.example.json");
|
|
assert_eq!(Project::from_json(example).unwrap().version, 15);
|
|
}
|
|
|
|
#[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 canvas_pilot::project::{Preview, Workspace};
|
|
let old = include_str!("../../../docs/interfaces/canvas-pilot-v10.example.json");
|
|
let migrated = Project::from_json(old).unwrap();
|
|
assert_eq!(migrated.workspace, Workspace::default());
|
|
let current = include_str!("../../../docs/interfaces/canvas-pilot-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 = canvas_pilot::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());
|
|
}
|