b45255bb6fe2
slot_tests.rs
//! `SLOT` layers of the REST file JSON: bound to their slot property in a main component, and
//! holding each instance's own content (synthetic files).
use super::*;
use serde_json::json;
fn at(x: f64, y: f64) -> Value {
json!([[1, 0, x], [0, 1, y]])
}
pub(crate) fn file(children: Value) -> Value {
json!({"name": "Slots", "schemaVersion": 0, "document": {"id": "0:0", "name": "Document", "type": "DOCUMENT", "children": [
{"id": "0:1", "name": "Page", "type": "CANVAS", "children": children}
]}})
}
fn content_id(local: u32) -> Value {
json!({"guid": {"sessionID": 5, "localID": local}})
}
fn slot(id: &str, name: &str, children: Value) -> Value {
json!({"id": id, "name": name, "type": "SLOT", "relativeTransform": at(10.0, 40.0), "size": {"x": 280, "y": 100}, "children": children})
}
fn label(id: &str, text: &str) -> Value {
json!({"id": id, "name": text, "type": "TEXT", "characters": text, "relativeTransform": at(0.0, 0.0), "size": {"x": 100, "y": 20}})
}
/// A "Chip" component (`1:9`), a "Container" component (`1:2`) with a "Title" text and an empty
/// "Slot" (property `Slot#1:3`, default content 5:1), and the given layers after them.
pub(crate) fn container_file(more: Vec<Value>) -> Value {
let mut layers = vec![
json!({"id": "1:9", "name": "Chip", "type": "COMPONENT", "relativeTransform": at(0.0, 400.0), "size": {"x": 40, "y": 20}, "children": [
{"id": "1:10", "name": "Dot", "type": "ELLIPSE", "relativeTransform": at(2.0, 2.0), "size": {"x": 16, "y": 16}}
]}),
json!({"id": "1:2", "name": "Container", "type": "COMPONENT", "relativeTransform": at(0.0, 0.0), "size": {"x": 300, "y": 160},
"componentPropertyDefinitions": {"Slot#1:3": {"type": "SLOT", "defaultValue": content_id(1)}},
"children": [label("1:4", "Title"), slot("1:5", "Slot", json!([]))]}),
];
layers.extend(more);
file(Value::Array(layers))
}
/// An instance `id` of Container at `x` whose slot holds `content` (property value `value`).
pub(crate) fn container(id: &str, x: f64, value: Value, content: Value) -> Value {
json!({"id": id, "name": "Container", "type": "INSTANCE", "componentId": "1:2", "relativeTransform": at(x, 0.0), "size": {"x": 300, "y": 160},
"componentProperties": {"Slot#1:3": {"type": "SLOT", "value": value}},
"children": [label(&format!("I{id};1:4"), "Title"), slot(&format!("I{id};1:5"), "Slot", content)]})
}
pub(crate) fn chip(id: &str) -> Value {
json!({"id": id, "name": "Chip", "type": "INSTANCE", "componentId": "1:9", "relativeTransform": at(0.0, 30.0), "size": {"x": 40, "y": 20}, "children": [
{"id": format!("I{id};1:10"), "name": "Dot", "type": "ELLIPSE", "relativeTransform": at(2.0, 2.0), "size": {"x": 16, "y": 16}}
]})
}
fn by_rest<'d>(doc: &'d Document, v: &Value, rest: &str) -> &'d Node {
// Names repeat across copies: find by position in the file's tree instead.
fn path(v: &Value, rest: &str, out: &mut Vec<usize>) -> bool {
if v.get("id").and_then(Value::as_str) == Some(rest) {
return true;
}
for (i, c) in v.get("children").and_then(Value::as_array).into_iter().flatten().enumerate() {
out.push(i);
if path(c, rest, out) {
return true;
}
out.pop();
}
false
}
let mut p = Vec::new();
assert!(path(&v["document"]["children"][0], rest, &mut p), "no {rest} in the file");
let mut id = doc.pages[0];
for i in p {
id = doc.node(id).unwrap().children[i];
}
doc.node(id).unwrap()
}
fn names(doc: &Document, n: &Node) -> Vec<String> {
n.children.iter().map(|c| doc.node(*c).unwrap().name.clone()).collect()
}
#[test]
fn slot_layers_bind_to_their_property_and_keep_instance_content() {
let v = container_file(vec![
container("2:1", 400.0, content_id(7), json!([label("2:2", "Reports in progress"), chip("2:3")])),
container("3:1", 800.0, content_id(1), json!([])),
]);
let (doc, warnings) = import(&v, &no_images).unwrap();
assert!(warnings.iter().all(|w| !w.contains("SLOT") && !w.contains("slot")), "{warnings:?}");
let main = by_rest(&doc, &v, "1:2");
let NodeKind::Component { props, .. } = &main.kind else { panic!("{:?}", main.kind) };
assert_eq!(props.get("Slot"), Some(&PropDef::Slot { preferred: Vec::new() }), "named without its #id suffix");
let main_slot = by_rest(&doc, &v, "1:5");
assert!(matches!(main_slot.kind, NodeKind::Frame));
assert_eq!(main_slot.prop_refs.get("slot").map(String::as_str), Some("Slot"));
assert!(main_slot.children.is_empty(), "the main's slot stays empty");
let filled = by_rest(&doc, &v, "I2:1;1:5");
assert!(filled.overrides.contains("slot"), "the instance's own content");
assert!(filled.prop_refs.is_empty(), "an instance's slot follows its main's");
assert_eq!(names(&doc, filled), ["Reports in progress", "Chip"]);
let chip = by_rest(&doc, &v, "2:3");
assert!(matches!(chip.kind, NodeKind::Instance { .. }), "instances in slot content link to their own main");
let default = by_rest(&doc, &v, "I3:1;1:5");
assert!(!default.overrides.contains("slot"), "the main's default content follows the main");
}
#[test]
fn slot_ownership_without_values_follows_the_content() {
let mut owned = container("2:1", 400.0, json!(null), json!([label("2:2", "Own")]));
owned["componentProperties"] = json!({});
let mut empty = container("3:1", 800.0, json!(null), json!([]));
empty["componentProperties"] = json!({});
let v = container_file(vec![owned, empty]);
let (doc, _) = import(&v, &no_images).unwrap();
assert!(by_rest(&doc, &v, "I2:1;1:5").overrides.contains("slot"));
assert!(!by_rest(&doc, &v, "I3:1;1:5").overrides.contains("slot"));
}
#[test]
fn slots_match_by_reference_then_name_then_the_one_left() {
let comp = json!({"id": "1:2", "name": "Card", "type": "COMPONENT", "relativeTransform": at(0.0, 0.0), "size": {"x": 300, "y": 300},
"componentPropertyDefinitions": {
"Header#1:3": {"type": "SLOT", "defaultValue": content_id(1)},
"Body#1:4": {"type": "SLOT", "defaultValue": content_id(2)},
"Footer#1:5": {"type": "SLOT", "defaultValue": content_id(3)},
"Visible#1:6": {"type": "BOOLEAN", "defaultValue": true}
},
"children": [
{"id": "1:7", "name": "Top", "type": "SLOT", "componentPropertyReferences": {"visible": "Visible#1:6", "slot": "Header#1:3"},
"relativeTransform": at(0.0, 0.0), "size": {"x": 300, "y": 50}},
{"id": "1:8", "name": "Body", "type": "SLOT", "relativeTransform": at(0.0, 50.0), "size": {"x": 300, "y": 50}},
{"id": "1:9", "name": "Bottom", "type": "SLOT", "relativeTransform": at(0.0, 100.0), "size": {"x": 300, "y": 50}}
]});
let v = file(json!([comp]));
let (doc, warnings) = import(&v, &no_images).unwrap();
assert!(warnings.is_empty(), "{warnings:?}");
let bound = |rest: &str| by_rest(&doc, &v, rest).prop_refs.get("slot").cloned();
assert_eq!(bound("1:7").as_deref(), Some("Header"));
assert_eq!(by_rest(&doc, &v, "1:7").prop_refs.get("visible").map(String::as_str), Some("Visible"));
assert_eq!(bound("1:8").as_deref(), Some("Body"));
assert_eq!(bound("1:9").as_deref(), Some("Footer"));
}
#[test]
fn variants_share_their_set_slot_property() {
let variant = |id: &str, name: &str, x: f64| {
json!({"id": id, "name": name, "type": "COMPONENT", "relativeTransform": at(x, 0.0), "size": {"x": 100, "y": 100},
"children": [slot(&format!("{id}s"), "Content", json!([]))]})
};
let set = json!({"id": "1:1", "name": "Panel", "type": "COMPONENT_SET", "relativeTransform": at(0.0, 0.0), "size": {"x": 300, "y": 100},
"componentPropertyDefinitions": {"Size": {"type": "VARIANT", "defaultValue": "Small"}, "Content#2:1": {"type": "SLOT", "defaultValue": content_id(1)}},
"children": [variant("1:2", "Size=Small", 0.0), variant("1:3", "Size=Large", 150.0)]});
let inst = json!({"id": "4:1", "name": "Panel", "type": "INSTANCE", "componentId": "1:3", "relativeTransform": at(0.0, 300.0), "size": {"x": 100, "y": 100},
"componentProperties": {"Content#2:1": {"type": "SLOT", "value": content_id(9)}},
"children": [slot("I4:1;1:3s", "Content", json!([label("4:2", "Mine")]))]});
let v = file(json!([set, inst]));
let (doc, warnings) = import(&v, &no_images).unwrap();
assert!(warnings.is_empty(), "{warnings:?}");
for rest in ["1:2s", "1:3s"] {
assert_eq!(by_rest(&doc, &v, rest).prop_refs.get("slot").map(String::as_str), Some("Content"), "{rest}");
}
assert!(by_rest(&doc, &v, "I4:1;1:3s").overrides.contains("slot"));
}
#[test]
fn nested_instances_own_the_slots_of_their_main() {
// A "Screen" main places a Container whose slot holds a chip; an instance of Screen places
// other content in that nested slot.
let screen = json!({"id": "6:1", "name": "Screen", "type": "COMPONENT", "relativeTransform": at(0.0, 600.0), "size": {"x": 300, "y": 160},
"children": [container("6:2", 0.0, content_id(7), json!([chip("6:3")]))]});
let nested = container("I7:1;6:2", 0.0, content_id(8), json!([label("7:2", "Other")]));
let outer = json!({"id": "7:1", "name": "Screen", "type": "INSTANCE", "componentId": "6:1", "relativeTransform": at(400.0, 600.0), "size": {"x": 300, "y": 160},
"children": [nested]});
let v = container_file(vec![screen, outer]);
let (doc, _) = import(&v, &no_images).unwrap();
let in_main = by_rest(&doc, &v, "I6:2;1:5");
assert!(in_main.overrides.contains("slot") && in_main.prop_refs.is_empty());
assert!(matches!(by_rest(&doc, &v, "6:3").kind, NodeKind::Instance { .. }));
let in_outer = by_rest(&doc, &v, "II7:1;6:2;1:5");
assert!(in_outer.overrides.contains("slot"));
assert_eq!(names(&doc, in_outer), ["Other"]);
}
#[test]
fn slots_outside_components_or_without_a_property_stay_frames() {
let mut no_def = container_file(Vec::new());
no_def["document"]["children"][0]["children"][1].as_object_mut().unwrap().remove("componentPropertyDefinitions");
let loose = slot("8:1", "Loose", json!([label("8:2", "Kept")]));
no_def["document"]["children"][0]["children"].as_array_mut().unwrap().push(loose);
let (doc, warnings) = import(&no_def, &no_images).unwrap();
assert!(warnings.iter().any(|w| w.starts_with("slot layers without a matching slot property were imported as frames (×2)")), "{warnings:?}");
let kept = by_rest(&doc, &no_def, "8:1");
assert!(matches!(kept.kind, NodeKind::Frame) && kept.prop_refs.is_empty());
assert_eq!(names(&doc, kept), ["Kept"]);
assert!(by_rest(&doc, &no_def, "1:5").prop_refs.is_empty());
}
#[test]
fn slot_settings_the_editor_cannot_keep_are_noted() {
let mut v = container_file(Vec::new());
v["document"]["children"][0]["children"][1]["componentPropertyDefinitions"]["Slot#1:3"]["slotSettings"] =
json!({"stretchChildOnInsert": true, "displayEmptyByDefault": true, "minChildren": null, "maxChildren": 3});
v["document"]["children"][0]["children"][1]["componentPropertyDefinitions"]["Slot#1:3"]["preferredValues"] =
json!([{"type": "COMPONENT", "key": "abc"}]);
let (_, warnings) = import(&v, &no_images).unwrap();
assert!(warnings.iter().any(|w| w == "non-default slot settings are not represented and were skipped"), "{warnings:?}");
assert!(warnings.iter().any(|w| w == "preferred slot component keys cannot be resolved to file nodes and were skipped"), "{warnings:?}");
let mut plain = container_file(Vec::new());
plain["document"]["children"][0]["children"][1]["componentPropertyDefinitions"]["Slot#1:3"]["slotSettings"] =
json!({"stretchChildOnInsert": true, "minChildren": null, "maxChildren": null, "allowPreferredValuesOnly": false});
assert!(import(&plain, &no_images).unwrap().1.is_empty());
}
#[test]
fn junk_slot_json_never_panics() {
for junk in [json!(null), json!(1), json!("x"), json!([]), json!({"guid": null}), json!({"type": "SLOT"})] {
let mut v = container_file(vec![container("2:1", 400.0, junk.clone(), json!([label("2:2", "A")]))]);
v["document"]["children"][0]["children"][1]["componentPropertyDefinitions"]["Slot#1:3"] =
json!({"type": "SLOT", "defaultValue": junk.clone(), "slotSettings": junk.clone(), "preferredValues": junk.clone()});
v["document"]["children"][0]["children"][1]["children"][1]["componentPropertyReferences"] = json!({"slot": junk});
assert!(import(&v, &no_images).is_ok());
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.