Files
materialcraft/crates/engine/tests/it/linked_instances.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

446 lines
23 KiB
Rust

use materialcraft_engine::{
Session,
core::{Graph, NodeId, OutputFormat, Package, Value},
execute, file_cmds, formats,
};
use serde_json::json;
fn source() -> (Package, NodeId) {
let mut package = Package::new("Source file");
let mut graph = Graph::new("Source");
graph.size = [4, 4];
graph.format = OutputFormat::F32;
let value = graph.add_node("uniform", [0.0; 2]);
graph.node_mut(value).unwrap().params.insert("color".into(), Value::Color([0.25, 0.5, 0.75, 1.0]));
let output = graph.add_node("output", [200.0, 0.0]);
graph.node_mut(output).unwrap().params.insert("identifier".into(), Value::Text("color".into()));
graph.connect(value, "output", output, "input").unwrap();
package.graphs.push(graph);
(package, value)
}
fn float_graph(name: &str) -> Graph {
let mut graph = Graph::new(name);
graph.format = OutputFormat::F32;
graph
}
fn open(session: &mut Session, package: &Package, file: &str) -> u64 {
file_cmds::open_bytes(session, &formats::sbs::write_sbs(package).unwrap(), Some(file.into())).unwrap();
session.document_id
}
#[test]
fn source_edits_update_instances_and_dirty_dependents_before_saving() {
let (source, value) = source();
let mut session = Session::new(source);
session.selection = vec![value];
session.path = Some(std::env::temp_dir().join("materialcraft-instance-source.sbs").to_string_lossy().into_owned());
let mut target = Package::new("Target file");
target.graphs.push(float_graph("Target"));
let target_id = open(&mut session, &target, "target.sbs");
let instance = NodeId(execute(&mut session, "graph.instance.add", &json!({"document": 0, "graph": "Source"})).unwrap()["id"].as_u64().unwrap());
session.preview_size = Some(16);
session.cook();
assert_eq!(session.output_ports(instance), ["color"]);
assert!(session.cooked.nodes[&instance].error.is_none(), "{:?}", session.cooked.nodes[&instance].error);
assert_eq!(session.cooked.image(instance, 0).unwrap().get(0, 0, false), [0.25, 0.5, 0.75, 1.0]);
let history = session.history();
session.modified = false;
execute(&mut session, "package.activate", &json!({"document": 0})).unwrap();
execute(&mut session, "graph.select", &json!({"ids": [value.0]})).unwrap();
execute(&mut session, "graph.node.param", &json!({"id": value.0, "param": "color", "value": [0.8, 0.2, 0.1, 1.0]})).unwrap();
assert!(session.open_packages().iter().find(|entry| entry.0 == target_id).unwrap().3);
execute(&mut session, "package.activate", &json!({"document": target_id})).unwrap();
assert_eq!(session.history(), history);
session.cook();
assert_eq!(session.cooked.image(instance, 0).unwrap().get(0, 0, false), [0.8, 0.2, 0.1, 1.0]);
execute(&mut session, "edit.undo", &json!({})).unwrap();
assert!(session.graph().unwrap().nodes.is_empty());
execute(&mut session, "edit.redo", &json!({})).unwrap();
session.cook();
assert_eq!(session.cooked.image(instance, 0).unwrap().get(0, 0, false), [0.8, 0.2, 0.1, 1.0]);
}
#[test]
fn creation_rejects_cycles_missing_outputs_and_incompatible_graph_kinds_atomically() {
let (package, _) = source();
let mut session = Session::new(package);
let before = session.pkg.clone();
assert!(execute(&mut session, "graph.instance.add", &json!({"document": 0, "graph": "Source"})).is_err());
assert_eq!(session.pkg, before);
assert!(!session.can_undo());
execute(&mut session, "file.new", &json!({"name": "Incomplete", "template": "empty"})).unwrap();
assert!(execute(&mut session, "graph.instance.add", &json!({"document": 0, "graph": "Incomplete"})).is_err());
assert!(execute(&mut session, "graph.instance.add", &json!({"document": 0, "graph": "Source", "pattern": 1})).is_err());
execute(&mut session, "file.new", &json!({"name": "Function", "kind": "function"})).unwrap();
assert!(execute(&mut session, "graph.instance.add", &json!({"document": 0, "graph": "Source"})).is_err());
}
#[test]
fn failed_edit_groups_do_not_publish_source_changes() {
let (source, value) = source();
let mut session = Session::new(source);
session.selection = vec![value];
session.path = Some(std::env::temp_dir().join("materialcraft-group-source.sbs").to_string_lossy().into_owned());
let mut target = Package::new("Target");
target.graphs.push(float_graph("Target"));
let target_id = open(&mut session, &target, "group-target.sbs");
let instance = NodeId(execute(&mut session, "graph.instance.add", &json!({"document": 0, "graph": "Source"})).unwrap()["id"].as_u64().unwrap());
session.modified = false;
execute(&mut session, "package.activate", &json!({"document": 0})).unwrap();
let result = session.group("Failed source edit", |session| {
execute(session, "graph.node.param", &json!({"id": value.0, "param": "color", "value": [1.0, 0.0, 0.0, 1.0]})).unwrap();
execute(session, "graph.node.param", &json!({"id": 99999, "param": "color", "value": [0.0, 0.0, 0.0, 0.0]}))
});
assert!(result.is_err());
assert!(!session.open_packages().iter().find(|entry| entry.0 == target_id).unwrap().3);
execute(&mut session, "package.activate", &json!({"document": target_id})).unwrap();
session.preview_size = Some(16);
session.cook();
assert_eq!(session.cooked.image(instance, 0).unwrap().get(0, 0, false), [0.25, 0.5, 0.75, 1.0]);
execute(&mut session, "package.activate", &json!({"document": 0})).unwrap();
session.begin_group("Complete source edit on package switch");
execute(&mut session, "graph.node.param", &json!({"id": value.0, "param": "color", "value": [1.0, 0.0, 0.0, 1.0]})).unwrap();
execute(&mut session, "package.activate", &json!({"document": target_id})).unwrap();
assert!(session.modified);
session.cook();
assert_eq!(session.cooked.image(instance, 0).unwrap().get(0, 0, false), [1.0, 0.0, 0.0, 1.0]);
}
#[test]
fn instance_info_is_read_only_and_describes_the_source_reference() {
let (source, _) = source();
let mut session = Session::new(source);
execute(&mut session, "file.new", &json!({"name": "Target", "template": "empty"})).unwrap();
let instance = execute(&mut session, "graph.instance.add", &json!({"document": 0, "graph": "Source"})).unwrap()["id"].as_u64().unwrap();
let before = session.pkg.clone();
let history = session.history();
let info = execute(&mut session, "graph.node.info", &json!({"id": instance})).unwrap();
let info: serde_json::Value = serde_json::from_str(info["text"].as_str().unwrap()).unwrap();
assert_eq!(info["instance"]["graph"], "Source");
assert_eq!(session.pkg, before);
assert_eq!(session.history(), history);
}
#[test]
fn updates_propagate_through_three_packages_and_cycles_are_rejected() {
let (source, value) = source();
let mut session = Session::new(source);
session.selection = vec![value];
session.path = Some(std::env::temp_dir().join("materialcraft-transitive-source.sbs").to_string_lossy().into_owned());
let mut target = Package::new("Target");
target.graphs.push(float_graph("Target"));
let middle = open(&mut session, &target, "transitive-middle.sbs");
let instance = execute(&mut session, "graph.instance.add", &json!({"document": 0, "graph": "Source"})).unwrap()["id"].as_u64().unwrap();
let output = execute(&mut session, "graph.node.add", &json!({"def": "output"})).unwrap()["id"].as_u64().unwrap();
execute(&mut session, "graph.connect", &json!({"from": instance, "fromPort": "color", "to": output})).unwrap();
session.modified = false;
let outer = open(&mut session, &target, "transitive-outer.sbs");
let instance = NodeId(execute(&mut session, "graph.instance.add", &json!({"document": middle, "graph": "Target"})).unwrap()["id"].as_u64().unwrap());
let output = execute(&mut session, "graph.node.add", &json!({"def": "output"})).unwrap()["id"].as_u64().unwrap();
execute(&mut session, "graph.connect", &json!({"from": instance, "to": output})).unwrap();
session.modified = false;
session.preview_size = Some(16);
session.cook();
assert_eq!(session.cooked.image(instance, 0).unwrap().get(0, 0, false), [0.25, 0.5, 0.75, 1.0]);
execute(&mut session, "package.activate", &json!({"document": 0})).unwrap();
assert!(execute(&mut session, "graph.instance.add", &json!({"document": outer, "graph": "Target"})).is_err());
execute(&mut session, "graph.node.param", &json!({"id": value.0, "param": "color", "value": [0.1, 0.2, 0.3, 1.0]})).unwrap();
assert!(session.open_packages().iter().filter(|entry| entry.0 != 0).all(|entry| entry.3));
execute(&mut session, "package.activate", &json!({"document": outer})).unwrap();
session.cook();
assert_eq!(session.cooked.image(instance, 0).unwrap().get(0, 0, false), [0.1, 0.2, 0.3, 1.0]);
}
#[test]
fn closing_a_modified_source_discards_its_unsaved_changes_in_dependents() {
let directory = std::env::temp_dir().join(format!("materialcraft-linked-discard-{}", std::process::id()));
std::fs::create_dir(&directory).unwrap();
let source_path = directory.join("source.sbs");
let (source, value) = source();
let mut session = Session::new(source);
session.selection = vec![value];
execute(&mut session, "file.save", &json!({"path": source_path})).unwrap();
let mut target = Package::new("Target");
target.graphs.push(float_graph("Target"));
let target_id = open(&mut session, &target, "discard-target.sbs");
let instance = NodeId(execute(&mut session, "graph.instance.add", &json!({"document": 0, "graph": "Source"})).unwrap()["id"].as_u64().unwrap());
execute(&mut session, "package.activate", &json!({"document": 0})).unwrap();
execute(&mut session, "graph.node.param", &json!({"id": value.0, "param": "color", "value": [1.0, 0.0, 0.0, 1.0]})).unwrap();
assert!(execute(&mut session, "package.close", &json!({})).is_err());
execute(&mut session, "package.close", &json!({"discard": true})).unwrap();
assert_eq!(session.document_id, target_id);
session.preview_size = Some(16);
session.cook();
let color = session.cooked.image(instance, 0).unwrap().get(0, 0, false);
assert!(color.into_iter().zip([0.25, 0.5, 0.75, 1.0]).all(|(actual, expected)| (actual - expected).abs() < 1e-6));
std::fs::remove_dir_all(directory).unwrap();
}
#[test]
fn named_value_inputs_and_outputs_keep_their_type_across_files() {
let mut source = Package::new("Value source");
let mut graph = Graph::new("Source");
let input = graph.add_node("input_value", [0.0; 2]);
graph.node_mut(input).unwrap().params.extend([("identifier".into(), Value::Text("number".into())), ("default".into(), Value::Float(0.25))]);
let output = graph.add_node("output", [200.0, 0.0]);
graph.node_mut(output).unwrap().params.insert("identifier".into(), Value::Text("result".into()));
graph.connect(input, "output", output, "input").unwrap();
source.graphs.push(graph);
let mut session = Session::new(source);
session.path = Some(std::env::temp_dir().join("materialcraft-value-source.sbs").to_string_lossy().into_owned());
let mut target = Package::new("Target");
target.graphs.push(float_graph("Target"));
open(&mut session, &target, "value-target.sbs");
let instance = NodeId(execute(&mut session, "graph.instance.add", &json!({"document": 0, "graph": "Source"})).unwrap()["id"].as_u64().unwrap());
let value = execute(&mut session, "graph.node.add", &json!({"def": "input_value", "params": {"default": 0.75}})).unwrap()["id"].as_u64().unwrap();
execute(&mut session, "graph.connect", &json!({"from": value, "to": instance, "toPort": "number"})).unwrap();
session.preview_size = Some(16);
session.cook();
let cooked = &session.cooked.nodes[&instance];
assert!(cooked.error.is_none(), "{:?}", cooked.error);
assert_eq!(cooked.outputs[0].as_value(), Some(&Value::Float(0.75)));
assert_eq!(session.output_ports(instance), ["result"]);
assert!(!materialcraft_engine::MaterialSource { graph: session.graph, node: instance, port: "result".into() }.is_image(&session.pkg));
let mut local = session.open_packages().into_iter().find(|entry| entry.0 == 0).unwrap().1.clone();
let mut caller = session.graph().unwrap().clone();
caller.node_mut(instance).unwrap().instance.as_mut().unwrap().package.clear();
local.graphs.push(caller);
local.dependencies.clear();
let bytes = formats::sbs::write_sbs(&local).unwrap();
let mut reopened = Session::new(formats::sbs::read_sbs(&bytes, "local.sbs", &|_| None).unwrap().pkg);
execute(&mut reopened, "graph.open", &json!({"graph": "Target"})).unwrap();
reopened.preview_size = Some(16);
reopened.cook();
let instance = reopened.graph().unwrap().nodes.iter().find(|node| node.def == "graph_instance").unwrap().id;
let cooked = &reopened.cooked.nodes[&instance];
assert!(cooked.error.is_none(), "{:?}", cooked.error);
assert_eq!(cooked.outputs[0].as_value(), Some(&Value::Float(0.75)));
}
#[test]
fn removing_a_source_output_does_not_erase_connected_instance_wires_on_save() {
let (source, _) = source();
let mut session = Session::new(source);
session.path = Some(std::env::temp_dir().join("materialcraft-port-source.sbs").to_string_lossy().into_owned());
let source_output = session.graph().unwrap().nodes.iter().find(|node| node.def == "output").unwrap().id;
let mut target = Package::new("Target");
target.graphs.push(float_graph("Target"));
let target_id = open(&mut session, &target, "port-target.sbs");
let instance = NodeId(execute(&mut session, "graph.instance.add", &json!({"document": 0, "graph": "Source"})).unwrap()["id"].as_u64().unwrap());
let output = execute(&mut session, "graph.node.add", &json!({"def": "output"})).unwrap()["id"].as_u64().unwrap();
execute(&mut session, "graph.connect", &json!({"from": instance, "fromPort": "color", "to": output})).unwrap();
execute(&mut session, "package.activate", &json!({"document": 0})).unwrap();
execute(&mut session, "graph.select", &json!({"ids": [source_output]})).unwrap();
execute(&mut session, "edit.delete", &json!({})).unwrap();
execute(&mut session, "package.activate", &json!({"document": target_id})).unwrap();
let bytes = file_cmds::save_bytes(&session).unwrap();
let read = formats::sbs::read_sbs(&bytes, "target.sbs", &|_| None).unwrap();
assert_eq!(read.pkg.graphs[0].connections.len(), 1);
session.preview_size = Some(16);
session.cook();
assert!(session.cooked.nodes[&instance].error.is_some());
}
#[test]
fn local_instances_follow_graph_renames_and_undo() {
let (source, _) = source();
let mut session = Session::new(source);
execute(&mut session, "file.new", &json!({"name": "Target", "template": "empty"})).unwrap();
let instance = NodeId(execute(&mut session, "graph.instance.add", &json!({"document": 0, "graph": "Source"})).unwrap()["id"].as_u64().unwrap());
execute(&mut session, "graph.rename", &json!({"graph": "Source", "name": "Renamed"})).unwrap();
assert_eq!(session.graph().unwrap().node(instance).unwrap().instance.as_ref().unwrap().graph, "Renamed");
execute(&mut session, "edit.undo", &json!({})).unwrap();
assert_eq!(session.graph().unwrap().node(instance).unwrap().instance.as_ref().unwrap().graph, "Source");
}
#[test]
fn extracting_a_selection_cannot_create_an_instance_without_outputs() {
let mut package = Package::new("Source");
package.graphs.push(Graph::new("Graph"));
let mut session = Session::new(package);
execute(&mut session, "graph.node.add", &json!({"def": "uniform"})).unwrap();
let before = session.pkg.clone();
let history = session.history();
assert!(execute(&mut session, "graph.createFromSelection", &json!({})).is_err());
assert_eq!(session.pkg, before);
assert_eq!(session.history(), history);
}
#[test]
fn saved_dependencies_reopen_without_source_files_in_explorer_and_missing_sources_keep_wires() {
let directory = std::env::temp_dir().join(format!("materialcraft-linked-roundtrip-{}", std::process::id()));
std::fs::create_dir(&directory).unwrap();
let source_path = directory.join("source.sbs");
let target_path = directory.join("target.sbs");
let (source, _) = source();
let mut session = Session::new(source);
execute(&mut session, "file.save", &json!({"path": source_path})).unwrap();
execute(&mut session, "file.newPackage", &json!({"name": "Target"})).unwrap();
execute(&mut session, "file.new", &json!({"name": "Target", "template": "empty"})).unwrap();
session.graph_mut().unwrap().format = OutputFormat::F32;
let instance = execute(&mut session, "graph.instance.add", &json!({"document": 0, "graph": "Source"})).unwrap()["id"].as_u64().unwrap();
let output = execute(&mut session, "graph.node.add", &json!({"def": "output"})).unwrap()["id"].as_u64().unwrap();
execute(&mut session, "graph.connect", &json!({"from": instance, "fromPort": "color", "to": output})).unwrap();
execute(&mut session, "file.save", &json!({"path": target_path})).unwrap();
let saved = std::fs::read_to_string(&target_path).unwrap();
assert!(saved.contains("filename v=\"source.sbs\""));
assert!(!saved.contains(&directory.to_string_lossy().to_string()));
let mut reopened = Session::new(Package::new("Initial"));
file_cmds::open_file(&mut reopened, target_path.to_str().unwrap()).unwrap();
assert!(reopened.load_warnings.is_empty(), "{:?}", reopened.load_warnings);
assert_eq!(reopened.open_packages().len(), 2);
execute(&mut reopened, "graph.open", &json!({"graph": "Target"})).unwrap();
reopened.preview_size = Some(16);
reopened.cook();
let graph = reopened.graph().unwrap();
let output = graph.nodes.iter().find(|node| node.def == "output").unwrap().id;
let color = reopened.cooked.image(output, 0).unwrap().get(0, 0, false);
assert!(color.into_iter().zip([0.25, 0.5, 0.75, 1.0]).all(|(actual, expected)| (actual - expected).abs() < 1e-6));
std::fs::remove_file(&source_path).unwrap();
let mut missing = Session::new(Package::new("Initial"));
file_cmds::open_file(&mut missing, target_path.to_str().unwrap()).unwrap();
execute(&mut missing, "graph.open", &json!({"graph": "Target"})).unwrap();
assert_eq!(missing.graph().unwrap().connections.len(), 1);
let resaved = file_cmds::save_bytes(&missing).unwrap();
let resaved = formats::sbs::read_sbs(&resaved, "target.sbs", &|_| None).unwrap();
assert_eq!(resaved.pkg.graph_by_name("Target").unwrap().1.connections.len(), 1);
assert!(missing.path.is_some());
std::fs::remove_dir_all(directory).unwrap();
}
fn assert_instance_color(session: &mut Session, instance: NodeId, expected: [f32; 4]) {
let cooked = session.cook();
assert_eq!(cooked.nodes[&instance].error, None);
let actual = cooked.image(instance, 0).unwrap().get(0, 0, false);
assert!(actual.into_iter().zip(expected).all(|(actual, expected)| (actual - expected).abs() < 1e-6), "{actual:?} != {expected:?}");
}
#[test]
fn instance_defaults_follow_current_source_inputs_before_and_after_save() {
for linked in [false, true] {
let directory = std::env::temp_dir().join(format!("materialcraft-current-inputs-{}-{linked}", std::process::id()));
std::fs::create_dir_all(&directory).unwrap();
let source_path = directory.join("source.sbs");
let target_path = directory.join("target.sbs");
let (package, value) = source();
let mut session = Session::new(package);
session.path = Some(source_path.to_string_lossy().into_owned());
execute(&mut session, "graph.exposed.add", &json!({"id": "tint", "bind": {"node": value, "param": "color"}})).unwrap();
execute(&mut session, "graph.exposed.set", &json!({"id": "tint", "value": [0.2, 0.3, 0.4, 1.0]})).unwrap();
let target_document = if linked {
let mut target = Package::new("Target");
target.graphs.push(float_graph("Target"));
open(&mut session, &target, target_path.to_str().unwrap())
} else {
execute(&mut session, "file.new", &json!({"name": "Target", "template": "empty"})).unwrap();
session.graph_mut().unwrap().format = OutputFormat::F32;
session.document_id
};
let target_graph = session.graph;
let instance = NodeId(execute(&mut session, "graph.instance.add", &json!({"document": 0, "graph": "Source"})).unwrap()["id"].as_u64().unwrap());
session.preview_size = Some(16);
for expected in [[0.2, 0.3, 0.4, 1.0], [0.8, 0.6, 0.4, 1.0]] {
execute(&mut session, "package.activate", &json!({"document": 0})).unwrap();
session.graph = 0;
execute(&mut session, "graph.exposed.set", &json!({"id": "tint", "value": expected})).unwrap();
execute(&mut session, "package.activate", &json!({"document": target_document})).unwrap();
session.graph = target_graph;
let cooked = session.cook();
assert_eq!(cooked.nodes[&instance].error, None);
assert_eq!(cooked.nodes[&instance].parameters["tint"], Value::Color(expected));
assert_instance_color(&mut session, instance, expected);
}
let source_bytes = formats::sbs::write_sbs(session.open_packages().iter().find(|entry| entry.0 == 0).unwrap().1).unwrap();
std::fs::write(&source_path, source_bytes).unwrap();
std::fs::write(&target_path, file_cmds::save_bytes(&session).unwrap()).unwrap();
let mut reopened = Session::new(Package::new("Initial"));
file_cmds::open_file(&mut reopened, target_path.to_str().unwrap()).unwrap();
assert!(reopened.load_warnings.is_empty(), "{:?}", reopened.load_warnings);
reopened.graph = target_graph;
reopened.preview_size = Some(16);
let instance = reopened.graph().unwrap().nodes.iter().find(|node| node.def == "graph_instance").unwrap().id;
assert_instance_color(&mut reopened, instance, [0.8, 0.6, 0.4, 1.0]);
execute(&mut reopened, "graph.node.param", &json!({"id": instance, "param": "tint", "value": [0.1, 0.2, 0.3, 1.0]})).unwrap();
assert_instance_color(&mut reopened, instance, [0.1, 0.2, 0.3, 1.0]);
execute(&mut reopened, "graph.node.reset", &json!({"id": instance, "param": "tint"})).unwrap();
assert_instance_color(&mut reopened, instance, [0.8, 0.6, 0.4, 1.0]);
std::fs::remove_dir_all(directory).unwrap();
}
}
#[test]
fn instance_constant_capture_uses_the_current_source_input_without_a_prior_cook() {
let (package, value) = source();
let mut session = Session::new(package);
execute(&mut session, "graph.exposed.add", &json!({"id": "tint", "bind": {"node": value, "param": "color"}})).unwrap();
execute(&mut session, "graph.exposed.set", &json!({"id": "tint", "value": [0.8, 0.6, 0.4, 1.0]})).unwrap();
execute(&mut session, "file.new", &json!({"name": "Target", "template": "empty"})).unwrap();
let instance = NodeId(execute(&mut session, "graph.instance.add", &json!({"document": 0, "graph": "Source"})).unwrap()["id"].as_u64().unwrap());
let info = execute(&mut session, "graph.node.parameterInfo", &json!({"id": instance, "param": "tint"})).unwrap();
assert_eq!(info["value"], json!(Value::Color([0.8, 0.6, 0.4, 1.0])));
execute(&mut session, "graph.node.function", &json!({"id": instance, "param": "tint", "mode": "constant"})).unwrap();
session.graph = 0;
execute(&mut session, "graph.exposed.set", &json!({"id": "tint", "value": [0.0, 0.0, 0.0, 1.0]})).unwrap();
session.graph = 1;
session.preview_size = Some(16);
assert_instance_color(&mut session, instance, [0.8, 0.6, 0.4, 1.0]);
}