SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
use serde_json::{Value, json};
use super::{Bom, BomParams, ComponentMetadataParams, ComponentMetadataResult, ComponentMetadataSetParams, ComponentMetadataSetResult};
use crate::Session;
use crate::schema::tests::{assert_keys, assert_strict_keeps_todays_errors, conforms};
use crate::schema::{ParamCheck, input_schema_for, output_schema_for};
fn run(s: &mut Session, id: &str, p: Value) -> Value {
s.execute(id, &p).unwrap_or_else(|e| panic!("{id} {p}: {e}"))
}
/// As in the command's own tests: a plate placed three times, and a hinge subassembly placed
/// twice that holds one pin. Here the hinge has a part number too, so it can keep its pin.
fn assembly(s: &mut Session) {
run(s, "component.create", json!({"name": "Plate"}));
run(s, "solid.box", json!({"length": 40, "width": 20, "height": 3}));
run(s, "component.activate", json!({"component": 0}));
run(s, "component.create", json!({"name": "Hinge", "activate": false}));
run(s, "component.create", json!({"name": "Pin", "parent": "Hinge"}));
run(s, "solid.cylinder", json!({"diameter": 4, "height": 30}));
run(s, "component.activate", json!({"component": 0}));
for x in [50, 100] {
run(s, "occurrence.copy", json!({"component": "Plate", "translate": [x, 0, 0]}));
}
run(s, "occurrence.copy", json!({"component": "Hinge", "translate": [0, 50, 0]}));
run(s, "component.metadata.set", json!({"component": "Plate", "part_number": "PL-100", "description": "Plate, 3 mm", "revision": "B"}));
run(s, "component.metadata.set", json!({"component": "Pin", "part_number": "PN-040", "properties": {"finish": "zinc"}}));
run(s, "component.metadata.set", json!({"component": "Hinge", "part_number": "HG-1"}));
}
#[test]
fn schemas_and_the_key_check_agree() {
assert_keys(input_schema_for::<BomParams>(), &["component", "format", "group_by", "group_children", "levels", "path"]);
assert_keys(input_schema_for::<ComponentMetadataParams>(), &["component"]);
assert_keys(
input_schema_for::<ComponentMetadataSetParams>(),
&["bom_type", "component", "description", "part_number", "properties", "revision", "values"],
);
}
#[test]
fn strict_keeps_todays_errors() {
let file = std::env::temp_dir().join(format!("solidcraft-bom-schema-{}.csv", std::process::id()));
let file = file.to_string_lossy();
assert_strict_keeps_todays_errors(&[
("assembly.bom", json!({"component": true})),
("assembly.bom", json!({"component": "Nope"})),
("assembly.bom", json!({"levels": "deep"})),
("assembly.bom", json!({"levels": 1})),
("assembly.bom", json!({"group_by": "size"})),
("assembly.bom", json!({"group_by": ["size"]})),
("assembly.bom", json!({"group_by": ["part_number", "definition"]})),
("assembly.bom", json!({"group_by": [5]})),
("assembly.bom", json!({"group_by": 5})),
("assembly.bom", json!({"group_children": "yes"})),
("assembly.bom", json!({"path": file.replace(".csv", ".txt")})),
("assembly.bom", json!({"path": file, "format": "xml"})),
("component.metadata", json!({})),
("component.metadata", json!({"component": null})),
("component.metadata", json!({"component": true})),
("component.metadata", json!({"component": [1]})),
("component.metadata", json!({"component": "Nope"})),
("component.metadata.set", json!({})),
("component.metadata.set", json!({"component": null, "part_number": "A"})),
("component.metadata.set", json!({"component": {"id": 1}, "part_number": "A"})),
("component.metadata.set", json!({"component": "Nope", "part_number": "A"})),
("component.metadata.set", json!({"component": 0, "part_number": "A"})),
("component.metadata.set", json!({"component": "root", "part_number": "A"})),
("component.metadata.set", json!({"component": 0, "values": 5})),
]);
// The cases that need a component to be there: a part with properties to set badly.
let mut s = Session { param_check: ParamCheck::Strict, ..Session::default() };
let mut off = Session { param_check: ParamCheck::Off, ..Session::default() };
for session in [&mut s, &mut off] {
run(session, "component.create", json!({"name": "Plate"}));
}
for p in [
json!({"component": "Plate"}),
json!({"component": "Plate", "values": null}),
json!({"component": "Plate", "values": [1]}),
json!({"component": "Plate", "values": "x"}),
json!({"component": "Plate", "properties": null}),
json!({"component": "Plate", "properties": ["a"]}),
json!({"component": "Plate", "values": (0..257).map(|i| (format!("org.k{i}"), json!({}))).collect::<serde_json::Map<_, _>>()}),
json!({"component": "Plate", "properties": (0..257).map(|i| (format!("p{i}"), json!("x"))).collect::<serde_json::Map<_, _>>()}),
json!({"component": "Plate", "part_number": 5}),
json!({"component": "Plate", "part_number": ["A"]}),
json!({"component": "Plate", "bom_type": "kit"}),
json!({"component": "Plate", "bom_type": 1}),
json!({"component": "Plate", "values": {"nope": "x"}}),
json!({"component": "Plate", "values": {"com.example.tool": "x"}}),
json!({"component": "Plate", "properties": {"": "x"}}),
json!({"component": "Plate", "properties": {"a": ["x"]}}),
json!({"component": "Plate", "properties": {"a": {"b": 1}}}),
json!({"component": "Plate", "description": "bad\u{7}"}),
json!({"component": "Plate", "properties": {"a": "bad\u{7}"}}),
] {
let (a, b) = (off.execute("component.metadata.set", &p), s.execute("component.metadata.set", &p));
assert!(a.is_err(), "{p} should fail today");
assert_eq!(a.map_err(|e| e.to_string()), b.map_err(|e| e.to_string()), "{p}");
}
}
/// #11075: a bill of materials replies as its output schema says, in Warn without warnings for
/// good calls and with them for a misspelt key: flat and top, grouped by definition, with the
/// hinge keeping its pin as children, and written to a JSON and a CSV file.
#[test]
fn a_bill_of_materials_replies_with_its_schema() {
let schema = output_schema_for::<Bom>();
let matches = |r: &Value, warned: bool| {
let schema = schema.as_value();
assert!(conforms(schema, schema, r), "{r} doesn't match {schema}");
assert_eq!(r.get("param_warnings").is_some(), warned, "{r}");
};
let mut s = Session { param_check: ParamCheck::Warn, ..Session::default() };
assembly(&mut s);
let r = run(&mut s, "assembly.bom", json!({}));
matches(&r, false);
assert!(r.get("path").is_none() && r["rows"].as_array().is_some_and(|rows| rows.iter().all(|row| row.get("children").is_none())), "{r}");
matches(&run(&mut s, "assembly.bom", json!({"component": 0, "levels": "top", "group_by": "definition"})), false);
let r = run(&mut s, "assembly.bom", json!({"levels": "flat", "group_by": ["part_number"], "group_children": true}));
matches(&r, false);
let hinge = r["rows"].as_array().and_then(|rows| rows.iter().find(|row| row["part_number"] == "HG-1")).cloned().unwrap_or_default();
assert_eq!((hinge["children"][0]["part_number"].as_str(), hinge["children"][0]["item"].is_string()), (Some("PN-040"), true), "{r}");
let dir = std::env::temp_dir();
for (name, format) in [("json", Value::Null), ("csv", json!("CSV"))] {
let path = dir.join(format!("solidcraft-bom-schema-{}.{name}", std::process::id())).to_string_lossy().into_owned();
let r = run(&mut s, "assembly.bom", json!({"path": path, "format": format}));
matches(&r, false);
assert_eq!(r["format"], name, "{r}");
let _ = std::fs::remove_file(&path);
}
matches(&run(&mut s, "assembly.bom", json!({"level": "top"})), true);
}
fn matches(schema: schemars::Schema, id: &str, reply: &Value, warned: bool) {
let schema = schema.as_value();
assert!(conforms(schema, schema, reply), "{id}: {reply} doesn't match {schema}");
assert_eq!(reply.get("param_warnings").is_some(), warned, "{id}: {reply}");
}
/// #12609: the types read each key as the handlers do, with their messages, and the check
/// accepts every form a handler takes today.
#[test]
fn the_part_property_types_read_keys_as_the_handlers_do() {
let issues = |id: &str, p: Value| crate::schema::issues(id, &p).into_iter().map(|i| i.message).collect::<Vec<_>>();
let none = Vec::<String>::new();
for id in ["component.metadata", "component.metadata.set"] {
let p = |component: Value| {
if id == "component.metadata" { json!({"component": component}) } else { json!({"component": component, "revision": "A"}) }
};
assert_eq!(issues(id, p(json!(3))), none, "{id}");
assert_eq!(issues(id, p(json!("Plate"))), none, "{id}");
assert_eq!(issues(id, p(json!(0))), none, "{id}");
assert_eq!(issues(id, p(json!("root"))), none, "{id}");
for bad in [json!(null), json!(true), json!([1]), json!({"a": 1})] {
assert_eq!(issues(id, p(bad.clone())), ["`component` must be a component id or name"], "{id} {bad}");
}
assert_eq!(issues(id, json!({"component": 1, "compnent": 1})).len(), 1, "{id}");
}
let set = |p: Value| issues("component.metadata.set", p);
// The keys that take text hand any value to the handler, which names what it refuses.
for k in ["part_number", "description", "revision", "bom_type"] {
for v in [json!("x"), json!(""), json!(null), json!(5), json!(["x"])] {
assert_eq!(set(json!({"component": 1, k: v})), none, "{k}");
}
}
assert_eq!(set(json!({"component": 1, "values": {"com.example.tool": {"a": 1}, "author": 5}})), none);
assert_eq!(set(json!({"component": 1, "properties": {"a": "x", "b": 2, "c": true, "d": null, "e": ["x"]}})), none);
// For the design the handler refuses before it reads anything else, so nothing else is read.
for root in [json!(0), json!("0"), json!("root"), json!("ROOT")] {
assert_eq!(set(json!({"component": root, "values": 5, "properties": null})), none, "{root}");
}
assert_eq!(set(json!({"component": 1, "values": null})), ["`values` must be an object: {key: value, …}"]);
assert_eq!(set(json!({"component": 1, "values": [1]})), ["`values` must be an object: {key: value, …}"]);
assert_eq!(set(json!({"component": 1, "properties": "a"})), ["`properties` must be an object: {name: text, …}"]);
let many = |prefix: &str| (0..257).map(|i| (format!("{prefix}{i}"), json!("x"))).collect::<serde_json::Map<_, _>>();
assert_eq!(set(json!({"component": 1, "values": many("org.k")})), ["`values` can hold at most 256 keys"]);
assert_eq!(set(json!({"component": 1, "properties": many("p")})), ["`properties` can hold at most 256 names"]);
let mut full = many("p");
full.remove("p256");
assert_eq!(set(json!({"component": 1, "properties": full, "values": {}})), none);
}
/// The schemas say what the handlers need: `component` is required though the types leave it to
/// the handlers' message, and the limits and shapes are those of the handlers.
#[test]
fn the_part_property_schemas_take_what_the_handlers_read() {
let takes = |schema: schemars::Schema, cases: &[(Value, bool)]| {
let schema = schema.as_value();
for (p, takes) in cases {
assert_eq!(conforms(schema, schema, p), *takes, "{p}");
}
};
takes(
input_schema_for::<ComponentMetadataParams>(),
&[(json!({"component": "Plate"}), true), (json!({"component": 0}), true), (json!({}), false), (json!({"component": true}), false)],
);
takes(
input_schema_for::<ComponentMetadataSetParams>(),
&[
(json!({"component": "Plate", "part_number": "P-1", "description": null, "revision": "", "bom_type": "phantom"}), true),
(
json!({"component": 2, "values": {"com.example.tool": {"a": 1}}, "properties": {"finish": "zinc", "n": 3, "b": true, "gone": null}}),
true,
),
(json!({"part_number": "P-1"}), false),
(json!({"component": "Plate", "part_number": 5}), false),
(json!({"component": "Plate", "values": []}), false),
],
);
}
/// Read and change part properties of a component and of the design, in Warn: each real reply
/// matches its output schema and carries no warning; a misspelt key's warning still matches.
#[test]
fn part_property_replies_match_the_output_schema() {
let mut s = Session { param_check: ParamCheck::Warn, ..Session::default() };
assembly(&mut s);
let read = |s: &mut Session, p: Value| {
let r = run(s, "component.metadata", p);
matches(output_schema_for::<ComponentMetadataResult>(), "component.metadata", &r, false);
r
};
let change = |s: &mut Session, p: Value| {
let r = run(s, "component.metadata.set", p);
matches(output_schema_for::<ComponentMetadataSetResult>(), "component.metadata.set", &r, false);
r
};
let plate = read(&mut s, json!({"component": "Plate"}));
assert_eq!(
(plate["part_number"].as_str(), plate["revision"].as_str(), plate["bom_type"].as_str()),
(Some("PL-100"), Some("B"), Some("normal")),
"{plate}"
);
let pin = read(&mut s, json!({"component": "Pin"}));
assert_eq!((pin["properties"]["finish"].as_str(), pin["revision"].is_null()), (Some("zinc"), true), "{pin}");
let root = read(&mut s, json!({"component": 0}));
assert!(root.get("bom_type").is_none() && root["properties"] == json!({}), "{root}");
read(&mut s, json!({"component": "root"}));
let by_id = read(&mut s, json!({"component": plate["component"]}));
assert_eq!(by_id["name"], "Plate");
let r = change(
&mut s,
json!({"component": "Plate", "revision": "C", "bom_type": "purchased", "properties": {"material": "1.4301", "n": 3, "ok": true}}),
);
assert_eq!(r["changed"], json!(["revision", "bom_type", "properties.material", "properties.n", "properties.ok"]), "{r}");
let r = change(
&mut s,
json!({"component": "Plate", "values": {"com.example.tool": {"a": 1}, "description": "Plate"}, "part_number": null, "properties": {"n": ""}}),
);
assert_eq!(r["changed"], json!(["com.example.tool", "description", "part_number", "properties.n"]), "{r}");
assert_eq!(r["properties"], json!({"material": "1.4301", "ok": "true"}), "{r}");
let r = change(&mut s, json!({"component": "Plate", "revision": "C"}));
assert_eq!(r["changed"], json!([]), "{r}");
assert_eq!(read(&mut s, json!({"component": "Plate"}))["metadata"]["com.example.tool"], json!({"a": 1}));
for (id, p) in [
("component.metadata", json!({"component": "Plate", "compnent": 1})),
("component.metadata.set", json!({"component": "Plate", "revision": "D", "revison": "E"})),
] {
let warned = run(&mut s, id, p);
assert!(warned["param_warnings"].as_array().is_some_and(|w| w.len() == 1), "{warned}");
if id == "component.metadata" {
matches(output_schema_for::<ComponentMetadataResult>(), id, &warned, true);
} else {
matches(output_schema_for::<ComponentMetadataSetResult>(), id, &warned, true);
}
}
}