Files
materialcraft/crates/engine/tests/it/graph_interaction.rs
chasse20 1a7225c8c2 Auto: Reuse SBS parsing and fix stale preview cache failures
Integrate main's read limits and preserve the font, evaluator, converter,
and measured preview repairs. Complete the scoped type, comment, and
spacing cleanup.

Reuse one validated XML document for library layout and graph reads.
Associate cache maintenance completion with its submitted revision so
old failures cannot consume new settings or clear requests.
2026-11-14 22:52:26 +00:00

298 lines
14 KiB
Rust

use materialcraft_engine::{
FunctionGraphTarget, Session,
core::{FunctionGraph, NodeId, Value},
execute,
formats::sbs::{read_sbs, write_sbs},
new_session,
};
use serde_json::json;
fn add(session: &mut Session, definition: &str) -> NodeId {
NodeId(execute(session, "graph.node.add", &json!({"def": definition})).unwrap()["id"].as_u64().unwrap())
}
#[test]
fn value_inputs_feed_authored_processors_and_round_trip() {
let mut session = new_session();
let input = add(&mut session, "input_value");
execute(&mut session, "graph.node.param", &json!({"id": input.0, "param": "default", "value": 0.35})).unwrap();
let first =
NodeId(execute(&mut session, "graph.node.add", &json!({"def": "value_processor", "connectFrom": {"node": input.0}})).unwrap()["id"].as_u64().unwrap());
let second = add(&mut session, "value_processor");
execute(&mut session, "graph.connect", &json!({"from": input.0, "to": second.0, "toPort": "value1"})).unwrap();
assert_eq!(session.graph().unwrap().connections.len(), 2);
assert!(session.undo().is_some());
assert_eq!(session.graph().unwrap().connections.len(), 1);
assert_eq!(session.graph().unwrap().connections[0].to, first);
assert!(session.redo().is_some());
for node in [first, second] {
let target = FunctionGraphTarget::Parameter { node, parameter: "function".into() };
assert_eq!(target.current(&session).unwrap(), &FunctionGraph::default());
let mut function = FunctionGraph::default();
function.output = Some(function.add("get_float1", &[], Some(Value::Text("value1".into()))));
execute(&mut session, "graph.function.set", &json!({"target": target, "function": function})).unwrap();
}
session.cook();
for node in [first, second] {
assert_eq!(session.cooked.value(node, 0), Some(&Value::Float(0.35)));
}
let bytes = write_sbs(&session.pkg).unwrap();
let loaded = read_sbs(&bytes, "fan_out.sbs", &|_| None).unwrap();
assert!(loaded.warnings.is_empty(), "{:?}", loaded.warnings);
let mut loaded = Session::new(loaded.pkg);
loaded.cook();
assert_eq!(loaded.graph().unwrap().connections.len(), 2);
for node in loaded.graph().unwrap().nodes.iter().filter(|node| node.def == "value_processor") {
assert_eq!(loaded.cooked.value(node.id, 0), Some(&Value::Float(0.35)));
assert!(loaded.cooked.nodes[&node.id].error.is_none());
}
}
#[test]
fn reconnection_is_atomic_and_preserves_other_branches() {
let mut session = new_session();
let input = add(&mut session, "input_value");
let first = add(&mut session, "value_processor");
let second = add(&mut session, "value_processor");
let third = add(&mut session, "value_processor");
for target in [first, second] {
execute(&mut session, "graph.connect", &json!({"from": input.0, "to": target.0})).unwrap();
}
let original = session.pkg.clone();
let invalid = json!({"from": input.0, "to": third.0, "toPort": "input0", "detach": {"to": first.0, "toPort": "value1"}});
assert!(execute(&mut session, "graph.connect", &invalid).is_err());
assert_eq!(session.pkg, original);
execute(&mut session, "graph.connect", &json!({"from": input.0, "to": third.0, "detach": {"to": first.0, "toPort": "value1"}})).unwrap();
let graph = session.graph().unwrap();
assert!(graph.input_of(first, "value1").is_none());
assert_eq!(graph.input_of(second, "value1").unwrap().from, input);
assert_eq!(graph.input_of(third, "value1").unwrap().from, input);
assert!(session.undo().is_some());
assert_eq!(session.pkg, original);
execute(&mut session, "graph.connect", &json!({"from": first.0, "to": third.0})).unwrap();
let original = session.pkg.clone();
let cycle = json!({"from": first.0, "to": first.0, "detach": {"to": third.0, "toPort": "value1"}});
assert!(execute(&mut session, "graph.connect", &cycle).is_err());
assert_eq!(session.pkg, original);
}
#[test]
fn clipboard_variants_keep_internal_wires_and_optionally_keep_incoming_links() {
let mut session = new_session();
let input = add(&mut session, "input_value");
let first = add(&mut session, "value_processor");
let second = add(&mut session, "value_processor");
execute(&mut session, "graph.connect", &json!({"from": input.0, "to": first.0})).unwrap();
execute(&mut session, "graph.connect", &json!({"from": first.0, "to": second.0})).unwrap();
execute(&mut session, "edit.copy", &json!({"ids": [first.0, second.0]})).unwrap();
for (command, incoming) in [("edit.paste", true), ("edit.pasteWithoutLinks", false), ("edit.duplicate", true), ("edit.duplicateWithoutLinks", false)] {
session.selection = vec![first, second];
execute(&mut session, command, &json!({"snapToGrid": true})).unwrap();
let selected = &session.selection;
let graph = session.graph().unwrap();
assert_eq!(graph.connections.iter().filter(|wire| selected.contains(&wire.from) && selected.contains(&wire.to)).count(), 1);
assert_eq!(graph.connections.iter().filter(|wire| wire.from == input && selected.contains(&wire.to)).count(), usize::from(incoming));
assert!(graph.nodes.iter().filter(|node| selected.contains(&node.id)).all(|node| node.pos.iter().all(|coordinate| coordinate % 32.0 == 0.0)));
}
execute(&mut session, "file.new", &json!({"template": "empty"})).unwrap();
execute(&mut session, "edit.paste", &json!({})).unwrap();
assert_eq!(session.graph().unwrap().connections.len(), 1);
}
#[test]
fn snapping_is_explicit_in_engine_commands_and_preserves_saved_positions() {
let mut session = new_session();
let result = execute(&mut session, "graph.node.add", &json!({"def": "uniform", "at": [19, -19], "snapToGrid": true})).unwrap();
let node = NodeId(result["id"].as_u64().unwrap());
assert_eq!(session.graph().unwrap().node(node).unwrap().pos, [32.0, -32.0]);
execute(&mut session, "graph.node.move", &json!({"by": [20, 20], "snapToGrid": true})).unwrap();
assert_eq!(session.graph().unwrap().node(node).unwrap().pos, [64.0, 0.0]);
execute(&mut session, "graph.node.move", &json!({"to": [19, -19], "snapToGrid": false})).unwrap();
assert_eq!(session.graph().unwrap().node(node).unwrap().pos, [19.0, -19.0]);
let loaded = read_sbs(&write_sbs(&session.pkg).unwrap(), "positions.sbs", &|_| None).unwrap();
assert_eq!(loaded.pkg.graphs[0].nodes[0].pos, [19.0, -19.0]);
}
#[test]
fn fx_map_starts_with_a_quadrant_and_grows_image_inputs_as_connected() {
use materialcraft_engine::core::PatternNodeKind;
let mut session = new_session();
session.preview_size = Some(16);
let source = add(&mut session, "uniform");
execute(&mut session, "graph.node.param", &json!({"id": source.0, "param": "color_mode", "value": false})).unwrap();
let owner = add(&mut session, "fx_map");
let Value::PatternGraph(pattern) = &session.graph().unwrap().node(owner).unwrap().params["pattern"] else { panic!("missing default pattern") };
assert_eq!(pattern.nodes.len(), 1);
assert_eq!(pattern.nodes[0].kind, PatternNodeKind::Quadrant);
assert_eq!(pattern.nodes[0].position, [0.0, 0.0]);
assert_eq!(pattern.root, Some(pattern.nodes[0].id));
assert_eq!(session.input_ports(owner), vec!["background", "pattern0"]);
let fresh = read_sbs(&write_sbs(&session.pkg).unwrap(), "fresh_pattern.sbs", &|_| None).unwrap();
assert!(fresh.warnings.is_empty(), "{:?}", fresh.warnings);
let loaded_pattern = fresh.pkg.graphs[0].nodes.iter().find(|node| node.def == "fx_map").unwrap();
let Value::PatternGraph(loaded_pattern) = &loaded_pattern.params["pattern"] else { panic!("missing saved root") };
assert_eq!(loaded_pattern.nodes.len(), 1);
assert_eq!(loaded_pattern.nodes[0].kind, PatternNodeKind::Quadrant);
assert_eq!(loaded_pattern.root, Some(loaded_pattern.nodes[0].id));
for index in 0..6 {
execute(&mut session, "graph.connect", &json!({"from": source.0, "to": owner.0, "toPort": format!("pattern{index}")})).unwrap();
assert_eq!(session.input_ports(owner).last(), Some(&format!("pattern{}", index + 1)));
}
let Value::PatternGraph(pattern) = &session.graph().unwrap().node(owner).unwrap().params["pattern"] else { panic!("missing pattern") };
let mut pattern = (**pattern).clone();
pattern.nodes[0].parameters.insert("patterntype".into(), Value::Int(1));
pattern.nodes[0].parameters.insert("imageindex".into(), Value::Int(6));
execute(&mut session, "graph.pattern.set", &json!({"id": owner.0, "pattern": pattern})).unwrap();
session.cook();
assert!(session.cooked.nodes[&owner].error.is_none(), "{:?}", session.cooked.nodes[&owner].error);
assert!((session.cooked.image(owner, 0).unwrap().mean()[0] - 0.5).abs() < 1e-5);
let bytes = write_sbs(&session.pkg).unwrap();
assert!(std::str::from_utf8(&bytes).unwrap().contains("<identifier v=\"inputpattern:5\"/>"));
let read = read_sbs(&bytes, "image_inputs.sbs", &|_| None).unwrap();
assert!(read.warnings.is_empty(), "{:?}", read.warnings);
let mut loaded = Session::new(read.pkg);
loaded.preview_size = Some(16);
let loaded_owner = loaded.graph().unwrap().nodes.iter().find(|node| node.def == "fx_map").unwrap().id;
assert_eq!(loaded.input_ports(loaded_owner), session.input_ports(owner));
loaded.cook();
assert!((loaded.cooked.image(loaded_owner, 0).unwrap().mean()[0] - 0.5).abs() < 1e-5);
execute(&mut session, "graph.disconnect", &json!({"to": owner.0, "toPort": "pattern5"})).unwrap();
assert_eq!(session.input_ports(owner).last().map(String::as_str), Some("pattern5"));
assert!(session.undo().is_some());
assert_eq!(session.input_ports(owner).last().map(String::as_str), Some("pattern6"));
let before = session.pkg.clone();
assert!(execute(&mut session, "graph.connect", &json!({"from": source.0, "to": owner.0, "toPort": "pattern999999999"})).is_err());
assert_eq!(session.pkg, before);
}
#[test]
fn terminal_outputs_cook_and_round_trip_without_source_pins() {
let mut session = new_session();
session.preview_size = Some(16);
let source = add(&mut session, "uniform");
let output = add(&mut session, "output");
execute(&mut session, "graph.connect", &json!({"from": source.0, "to": output.0})).unwrap();
assert_eq!(session.input_ports(output), vec!["input"]);
assert!(session.output_ports(output).is_empty());
let before = session.pkg.clone();
assert!(execute(&mut session, "graph.connect", &json!({"from": output.0, "to": source.0})).is_err());
assert_eq!(session.pkg, before);
let read = read_sbs(&write_sbs(&session.pkg).unwrap(), "terminal_output.sbs", &|_| None).unwrap();
assert!(read.warnings.is_empty(), "{:?}", read.warnings);
let mut loaded = Session::new(read.pkg);
loaded.preview_size = Some(16);
loaded.cook();
let output = loaded.graph().unwrap().nodes.iter().find(|node| node.def == "output").unwrap().id;
assert!(loaded.output_ports(output).is_empty());
assert!(loaded.cooked.nodes[&output].error.is_none());
assert!((loaded.cooked.image(output, 0).unwrap().mean()[0] - 0.5).abs() < 1e-5);
execute(&mut loaded, "view.2d", &json!({"node": output.0})).unwrap();
assert_eq!(loaded.view2d_image().unwrap().0, output);
}
#[test]
fn processors_sample_dynamic_image_inputs_after_sbs_round_trip() {
use materialcraft_engine::core::FunctionGraph;
for definition in ["pixel_processor", "value_processor"] {
let mut session = new_session();
session.graph_mut().unwrap().format = materialcraft_engine::core::OutputFormat::F32;
session.preview_size = Some(16);
let source = add(&mut session, "uniform");
let processor = add(&mut session, definition);
for index in 0..6 {
execute(&mut session, "graph.connect", &json!({"from": source.0, "to": processor.0, "toPort": format!("input{index}")})).unwrap();
assert_eq!(session.input_ports(processor).last(), Some(&format!("input{}", index + 1)));
}
let mut function = FunctionGraph::default();
let position = function.add_constant(Value::Float2([0.5, 0.5]));
function.output = Some(function.add("samplelum", &[position], Some(Value::Int2([5, 1]))));
execute(&mut session, "graph.node.param", &json!({"id": processor.0, "param": "function", "value": Value::Function(Box::new(function))})).unwrap();
let bytes = write_sbs(&session.pkg).unwrap();
assert!(std::str::from_utf8(&bytes).unwrap().contains("<identifier v=\"input:5\"/>"));
let read = read_sbs(&bytes, "processor_images.sbs", &|_| None).unwrap();
assert!(read.warnings.is_empty(), "{:?}", read.warnings);
let mut loaded = Session::new(read.pkg);
loaded.preview_size = Some(16);
loaded.cook();
let processor = loaded.graph().unwrap().nodes.iter().find(|node| node.def == definition).unwrap().id;
assert_eq!(loaded.input_ports(processor).last().map(String::as_str), Some("input6"));
assert!(loaded.cooked.nodes[&processor].error.is_none(), "{:?}", loaded.cooked.nodes[&processor].error);
if definition == "value_processor" {
assert_eq!(loaded.cooked.value(processor, 0), Some(&Value::Float(0.5)));
} else {
assert!((loaded.cooked.image(processor, 0).unwrap().mean()[0] - 0.5).abs() < 1e-5);
}
}
}
#[test]
fn background_pins_preserve_connected_images_through_sbs() {
let mut session = new_session();
session.preview_size = Some(16);
let source = add(&mut session, "uniform");
for definition in ["text", "svg"] {
let target = add(&mut session, definition);
if definition == "text" {
execute(&mut session, "graph.node.param", &json!({"id": target.0, "param": "text", "value": ""})).unwrap();
}
execute(&mut session, "graph.connect", &json!({"from": source.0, "to": target.0, "toPort": "background"})).unwrap();
}
let read = read_sbs(&write_sbs(&session.pkg).unwrap(), "backgrounds.sbs", &|_| None).unwrap();
assert!(read.warnings.is_empty(), "{:?}", read.warnings);
let mut loaded = Session::new(read.pkg);
loaded.preview_size = Some(16);
loaded.cook();
for node in loaded.graph().unwrap().nodes.iter().filter(|node| matches!(node.def.as_str(), "text" | "svg")) {
assert_eq!(loaded.input_ports(node.id), vec!["background"]);
let image = loaded.cooked.image(node.id, 0).unwrap();
assert_eq!(image.is_gray(), node.def == "text");
assert!((image.mean()[0] - 0.5).abs() < 1e-5);
assert!(loaded.cooked.nodes[&node.id].error.is_none());
}
}