Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

42.4 KB
Raw Blame
use serde_json::{Value, json};

use super::{
    BodyRenameParams, BodyRenamed, BrowserFoldParams, BrowserFoldResult, BrowserGroupMade, BrowserGroupParams, BrowserGroupRenamed,
    BrowserMoveParams, BrowserMoved, BrowserOrderParams, BrowserOrdered, BrowserRenameGroupParams, BrowserUngroupParams, BrowserUngrouped,
    BrowserVisibilityParams, BrowserVisibilityResult, DocumentUnitsParams, DocumentUnitsResult, RedefineSketchParams, RedefineSketchResult,
    RepairParams, RepairResult, ViewApplyParams, ViewDeleteParams, ViewDeleted, ViewListParams, ViewListResult, ViewRenameParams, ViewRenamed,
    ViewSaveParams, ViewSaved, VisibilityState,
};
use crate::Session;
use crate::schema::tests::{assert_keys, assert_strict_keeps_todays_errors, conforms};
use crate::schema::view_navigation::CameraReply;
use crate::schema::{ParamCheck, input_schema_for, output_schema_for};

#[test]
fn schemas_and_the_key_check_agree() {
    assert_keys(input_schema_for::<RepairParams>(), &["body", "body_name", "body_names", "gap", "name", "participants", "patch_holes"]);
}

#[test]
fn replies_match_the_output_schema() {
    let schema = output_schema_for::<RepairResult>();
    let schema = schema.as_value();
    let required: Vec<&str> = schema.get("required").and_then(Value::as_array).into_iter().flatten().filter_map(Value::as_str).collect();
    assert!(!required.contains(&"param_warnings"));
    let mut s = Session::default();
    s.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10, "body_name": "Box"})).unwrap();
    s.execute("surface.unstitch", &json!({"body": "Box", "faces": [[5, 5, 10]]})).unwrap();
    s.param_check = ParamCheck::Warn;
    let r = s.execute("body.repair", &json!({"body": "Box", "gap": "0.1 mm", "patch_holes": true, "name": "Mend"})).unwrap();
    assert!(r.get("param_warnings").is_none(), "{r}");
    assert!(conforms(schema, schema, &r), "{r} doesn't match {schema}");
    let r = s.execute("body.repair", &json!({"body": "Box", "colour": "red"}));
    assert!(r.is_err(), "nothing left to repair");
}

#[test]
fn units_schemas_and_the_key_check_agree() {
    assert_keys(input_schema_for::<DocumentUnitsParams>(), &["units"]);
}

#[test]
fn units_strict_keeps_todays_errors() {
    assert_strict_keeps_todays_errors(&[("document.units", json!({})), ("document.units", json!({"units": "furlong"}))]);
}

/// A change that keeps a parameter's value with the old unit, one that keeps none, and the same
/// units again, in Warn: each reply matches the output schema and carries no warning.
#[test]
fn units_replies_match_the_output_schema() {
    let schema = output_schema_for::<DocumentUnitsResult>();
    let schema = schema.as_value();
    let mut s = Session { param_check: ParamCheck::Warn, ..Session::default() };
    let mut run = |p: Value| s.execute("document.units", &p).unwrap_or_else(|e| panic!("{p}: {e}"));
    let mut check = |p: Value| {
        let reply = run(p.clone());
        assert!(reply.get("param_warnings").is_none() && conforms(schema, schema, &reply), "{p}: {reply} doesn't match {schema}");
        reply
    };
    check(json!({"units": "cm"}));
    assert_eq!(check(json!({"units": "cm"}))["kept"], json!([]));
    check(json!({"units": "in"}));
}

/// A unit-less parameter a length reads is kept with the old unit, and the reply names it.
#[test]
fn the_reply_names_the_parameters_kept_in_the_old_unit() {
    let mut s = Session::default();
    s.execute("parameters.add", &json!({"name": "w", "expression": "10", "unit": ""})).unwrap_or_else(|e| panic!("{e}"));
    s.execute("solid.box", &json!({"length": "w", "width": 10, "height": 10})).unwrap_or_else(|e| panic!("{e}"));
    let reply = s.execute("document.units", &json!({"units": "in"})).unwrap_or_else(|e| panic!("{e}"));
    let schema = output_schema_for::<DocumentUnitsResult>();
    assert!(conforms(schema.as_value(), schema.as_value(), &reply), "{reply}");
    assert_eq!(reply["kept"], json!(["w"]), "{reply}");
}

#[test]
fn browser_schemas_and_the_key_check_agree() {
    assert_keys(input_schema_for::<BodyRenameParams>(), &["body", "name"]);
    assert_keys(input_schema_for::<BrowserGroupParams>(), &["component", "folder", "items", "name", "parent"]);
    assert_keys(input_schema_for::<BrowserUngroupParams>(), &["group"]);
    assert_keys(input_schema_for::<BrowserRenameGroupParams>(), &["group", "name"]);
    assert_keys(input_schema_for::<BrowserMoveParams>(), &["before", "component", "folder", "group", "items"]);
    assert_keys(input_schema_for::<BrowserOrderParams>(), &["component", "folder", "order"]);
    assert_keys(
        input_schema_for::<BrowserVisibilityParams>(),
        &["features", "folder", "isolate", "items", "joints", "path", "paths", "tree_folders", "visible"],
    );
    assert_keys(input_schema_for::<BrowserFoldParams>(), &["component", "path"]);
}

/// Each call has one problem the handler already refuses: strict gives its message. (A missing
/// key is left to the handler, so the message is the handler's too.)
#[test]
fn browser_strict_keeps_todays_errors() {
    let long = "n".repeat(129);
    let deep: Vec<u64> = (1..=65).collect();
    assert_strict_keeps_todays_errors(&[
        ("body.rename", json!({})),
        ("body.rename", json!({"body": 5, "name": "X"})),
        ("body.rename", json!({"body": null, "name": "X"})),
        ("browser.group", json!({})),
        ("browser.group", json!({"folder": "components"})),
        ("browser.group", json!({"folder": null})),
        ("browser.group", json!({"folder": "bodies", "parent": "x"})),
        ("browser.group", json!({"folder": "bodies", "name": long})),
        ("browser.group", json!({"folder": "bodies", "items": [1]})),
        ("browser.group", json!({"folder": "bodies", "items": "A"})),
        ("browser.group", json!({"folder": "bodies", "items": null})),
        ("browser.group", json!({"folder": "bodies", "items": [""]})),
        ("browser.group", json!({"folder": "bodies", "items": [true]})),
        ("browser.move", json!({"folder": "bodies", "items": vec!["A"; 10_001]})),
        ("browser.move", json!({"folder": "bodies", "items": ["k".repeat(257)]})),
        ("browser.order", json!({"folder": "bodies", "order": vec!["A"; 10_001]})),
        ("browser.ungroup", json!({})),
        ("browser.ungroup", json!({"group": "g"})),
        ("browser.ungroup", json!({"group": null})),
        ("browser.ungroup", json!({"group": 99})),
        ("browser.rename_group", json!({})),
        ("browser.rename_group", json!({"group": -1, "name": "x"})),
        ("browser.move", json!({})),
        ("browser.move", json!({"folder": "bodies"})),
        ("browser.move", json!({"folder": "bodies", "items": []})),
        ("browser.move", json!({"folder": "bodies", "items": [true]})),
        ("browser.move", json!({"folder": "bodies", "items": [""]})),
        ("browser.move", json!({"folder": "bodies", "items": "A"})),
        ("browser.move", json!({"folder": "bodies", "items": ["A"], "group": "g"})),
        ("browser.move", json!({"folder": "bodies", "items": ["A"], "before": true})),
        ("browser.move", json!({"folder": "origin", "items": ["A"]})),
        ("browser.order", json!({})),
        ("browser.order", json!({"folder": "origin"})),
        ("browser.order", json!({"folder": "bodies", "order": null})),
        ("browser.order", json!({"folder": "bodies", "order": [true]})),
        ("browser.order", json!({"folder": "bodies", "order": ["A", ""]})),
        ("browser.visibility", json!({})),
        ("browser.visibility", json!({"visible": "yes"})),
        ("browser.visibility", json!({"visible": true})),
        ("browser.visibility", json!({"visible": true, "tree_folders": []})),
        ("browser.visibility", json!({"visible": true, "tree_folders": ["bodies"]})),
        ("browser.visibility", json!({"visible": true, "tree_folders": [3]})),
        ("browser.visibility", json!({"visible": true, "paths": []})),
        ("browser.visibility", json!({"visible": true, "paths": [[]]})),
        ("browser.visibility", json!({"visible": true, "paths": [["a"]]})),
        ("browser.visibility", json!({"visible": true, "paths": [deep]})),
        ("browser.visibility", json!({"visible": true, "joints": []})),
        ("browser.visibility", json!({"visible": true, "joints": [true]})),
        ("browser.visibility", json!({"visible": true, "folder": "nowhere"})),
        ("browser.visibility", json!({"visible": true, "items": "A"})),
        ("browser.visibility", json!({"visible": true, "items": null})),
        ("browser.visibility", json!({"visible": true, "items": [""]})),
        ("browser.visibility", json!({"visible": true, "items": []})),
        ("browser.visibility", json!({"visible": true, "features": [true]})),
        ("browser.expand_all", json!({"path": []})),
        ("browser.expand_all", json!({"path": null})),
        ("browser.expand_all", json!({"path": "o:1"})),
        ("browser.expand_all", json!({"path": [1, "a"]})),
        ("browser.expand_all", json!({"component": "root"})),
        ("browser.collapse_all", json!({"component": null})),
        ("browser.collapse_all", json!({"component": -1})),
        ("browser.collapse_all", json!({"path": deep})),
    ]);
}

/// The same, for the keys that need a body or a group to get as far as their message.
#[test]
fn browser_strict_keeps_todays_errors_for_names() {
    let long = "n".repeat(129);
    let cases = [
        ("body.rename", json!({"body": "Box", "name": ""})),
        ("body.rename", json!({"body": "Box", "name": "   "})),
        ("body.rename", json!({"body": "Box", "name": 5})),
        ("body.rename", json!({"body": "Box", "name": null})),
        ("body.rename", json!({"body": "Box", "name": long})),
        ("body.rename", json!({"body": "Box"})),
        ("browser.rename_group", json!({"group": "@g", "name": ""})),
        ("browser.rename_group", json!({"group": "@g", "name": 5})),
        ("browser.rename_group", json!({"group": "@g", "name": long})),
        ("browser.rename_group", json!({"group": "@g"})),
        ("browser.group", json!({"parent": "@g", "folder": "sketches"})),
        ("browser.group", json!({"parent": "@g", "folder": null})),
        ("browser.group", json!({"folder": "bodies", "parent": 77})),
        ("browser.move", json!({"folder": "bodies", "items": ["Box"], "before": 77})),
    ];
    for (id, p) in cases {
        let run = |level: ParamCheck| {
            let mut s = Session { param_check: level, ..Session::default() };
            s.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10, "body_name": "Box"})).unwrap();
            let g = s.execute("browser.group", &json!({"folder": "bodies", "name": "G"})).unwrap()["group"].clone();
            let p: Value = serde_json::from_str(&p.to_string().replace("\"@g\"", &g.to_string())).unwrap();
            s.execute(id, &p).err().map(|e| e.to_string())
        };
        let off = run(ParamCheck::Off);
        assert!(off.is_some(), "{id} {p} should fail today");
        assert_eq!(run(ParamCheck::Strict), off, "{id} {p}");
    }
}

/// The contracts say what the handlers need: the keys that can't be left out are required, an
/// order may be left out, and a folder is one the handler takes.
#[test]
fn the_browser_schemas_take_what_the_handlers_read() {
    let required = |schema: schemars::Schema| {
        let v = schema.as_value();
        let mut r: Vec<String> =
            v.get("required").and_then(Value::as_array).into_iter().flatten().filter_map(Value::as_str).map(String::from).collect();
        r.sort();
        r
    };
    assert_eq!(required(input_schema_for::<BodyRenameParams>()), ["body", "name"]);
    assert_eq!(required(input_schema_for::<BrowserGroupParams>()), Vec::<String>::new());
    assert_eq!(required(input_schema_for::<BrowserUngroupParams>()), ["group"]);
    assert_eq!(required(input_schema_for::<BrowserRenameGroupParams>()), ["group", "name"]);
    assert_eq!(required(input_schema_for::<BrowserMoveParams>()), ["folder", "items"]);
    assert_eq!(required(input_schema_for::<BrowserOrderParams>()), ["folder"]);
    assert_eq!(required(input_schema_for::<BrowserVisibilityParams>()), ["visible"]);
    assert_eq!(required(input_schema_for::<BrowserFoldParams>()), Vec::<String>::new());
    let mv = input_schema_for::<BrowserMoveParams>();
    let mv = mv.as_value();
    for (p, takes) in [
        (json!({"folder": "bodies", "items": ["A", 3], "group": 3, "before": "B"}), true),
        (json!({"folder": "bodies", "items": []}), false),
        (json!({"folder": "origin", "items": ["A"]}), false),
        (json!({"items": ["A"]}), false),
    ] {
        assert_eq!(conforms(mv, mv, &p), takes, "{p}");
    }
    let order = input_schema_for::<BrowserOrderParams>();
    let order = order.as_value();
    assert!(conforms(order, order, &json!({"folder": "components", "order": []})));
}

/// The typed visibility has the keys the saved one has, with every field set.
#[test]
fn the_visibility_reply_type_matches_the_design_s() {
    let v = solidcraft_doc::Visibility {
        hidden_bodies: vec!["A".into()],
        hidden_occurrences: vec![vec![1, 2]],
        hidden_origin: vec!["X".into()],
        hidden_sketches: vec![4],
        shown_sketches: vec![5],
        hidden_joints: vec![6],
        origin_hidden: Some(true),
        hidden_profiles: vec![7],
        shown_dimensions: vec![8],
        locked_bodies: vec!["B".into()],
        hidden_folders: vec!["c0/bodies".into()],
    };
    assert_eq!(serde_json::to_value(VisibilityState::from(&v)).unwrap(), serde_json::to_value(&v).unwrap());
    let empty = solidcraft_doc::Visibility::default();
    assert_eq!(serde_json::to_value(VisibilityState::from(&empty)).unwrap(), serde_json::to_value(&empty).unwrap());
}

/// #12276: every command replies as its output schema says, in Warn without warnings, in each
/// form it takes; a misspelt key's warning still matches.
#[test]
fn browser_commands_reply_with_their_schemas() {
    let mut s = Session { param_check: ParamCheck::Warn, ..Session::default() };
    // A placed component, for the placement forms.
    let part = s.execute("component.create", &json!({"name": "Part", "grounded": false})).unwrap_or_else(|e| panic!("{e}"));
    s.execute("component.activate", &json!({"component": 0})).unwrap_or_else(|e| panic!("{e}"));
    let occ = part["occurrence"].clone();
    let mut run = |id: &str, p: Value, schema: schemars::Schema| {
        let r = s.execute(id, &p).unwrap_or_else(|e| panic!("{id} {p}: {e}"));
        let schema = schema.as_value();
        assert!(r.get("param_warnings").is_none(), "{id} {p}: {r}");
        assert!(conforms(schema, schema, &r), "{id} {p}: {r} doesn't match {schema}");
        r
    };
    for (i, name) in ["A", "B", "C"].into_iter().enumerate() {
        run(
            "solid.box",
            json!({"length": 10, "width": 10, "height": 10, "corner": [i as f64 * 20.0, 0, 0], "body_name": name}),
            output_schema_for::<crate::schema::features::FeatureResult>(),
        );
    }
    let made = run("browser.group", json!({"folder": "bodies", "items": ["A"], "name": " Parts "}), output_schema_for::<BrowserGroupMade>());
    assert_eq!(made["parent"], Value::Null, "{made}");
    let outer = made["group"].clone();
    let inner = run("browser.group", json!({"parent": outer, "items": ["B"], "component": 0}), output_schema_for::<BrowserGroupMade>());
    assert_eq!(inner["parent"], outer, "{inner}");
    let renamed = run("browser.rename_group", json!({"group": inner["group"], "name": " Inner "}), output_schema_for::<BrowserGroupRenamed>());
    assert_eq!(renamed["name"], "Inner", "{renamed}");
    let moved = run(
        "browser.move",
        json!({"folder": "bodies", "items": ["C", inner["group"]], "group": outer, "before": "A"}),
        output_schema_for::<BrowserMoved>(),
    );
    assert_eq!(moved["items"], json!(["C", inner["group"]]), "{moved}");
    let top = run("browser.move", json!({"folder": "bodies", "items": ["C"], "group": null}), output_schema_for::<BrowserMoved>());
    assert_eq!(top["group"], Value::Null, "{top}");
    run("browser.order", json!({"folder": "bodies", "order": ["C", outer]}), output_schema_for::<BrowserOrdered>());
    let cleared = run("browser.order", json!({"folder": "bodies"}), output_schema_for::<BrowserOrdered>());
    assert_eq!(cleared, json!({}), "{cleared}");
    run("browser.ungroup", json!({"group": inner["group"]}), output_schema_for::<BrowserUngrouped>());

    let visibility = output_schema_for::<BrowserVisibilityResult>;
    for p in [
        json!({"visible": false, "items": ["A", "xy"]}),
        json!({"visible": true, "items": ["A"]}),
        json!({"visible": false, "folder": "bodies"}),
        json!({"visible": true, "folder": "all"}),
        json!({"visible": false, "features": ["Box1"]}),
        json!({"visible": false, "tree_folders": ["c0/bodies", format!("c0/g{outer}")]}),
        json!({"visible": false, "paths": [[occ]]}),
        json!({"visible": true, "paths": [[occ]], "isolate": true}),
        json!({"visible": true, "items": ["B"], "isolate": true}),
    ] {
        let r = run("browser.visibility", p.clone(), visibility());
        assert!(r["visibility"].is_object(), "{p}: {r}");
        assert_eq!(r.get("isolated").is_some(), p.get("isolate").is_some(), "{p}: {r}");
        assert_eq!(r.get("changed").is_some(), p.get("isolate").is_none(), "{p}: {r}");
    }
    let fold = output_schema_for::<BrowserFoldResult>;
    for (id, p, open) in [
        ("browser.expand_all", json!({}), true),
        ("browser.expand_all", json!({"path": [occ]}), true),
        ("browser.collapse_all", json!({"component": 0}), false),
        ("browser.collapse_all", json!({"path": [occ]}), false),
    ] {
        assert_eq!(run(id, p, fold())["open"], open);
    }
    let renamed = run("body.rename", json!({"body": "A", "name": " Alpha "}), output_schema_for::<BodyRenamed>());
    assert_eq!(renamed, json!({"body": "A", "name": "Alpha"}), "{renamed}");
    let same = run("body.rename", json!({"body": "Alpha", "name": "Alpha"}), output_schema_for::<BodyRenamed>());
    assert_eq!(same, json!({"body": "Alpha", "name": "Alpha"}), "{same}");

    // A misspelt key still runs in warn, and says so; strict refuses it.
    let p = json!({"visible": true, "folder": "all", "itms": []});
    let r = s.execute("browser.visibility", &p).unwrap_or_else(|e| panic!("{p}: {e}"));
    let schema = output_schema_for::<BrowserVisibilityResult>();
    assert!(r["param_warnings"].to_string().contains("itms") && conforms(schema.as_value(), schema.as_value(), &r), "{r}");
    s.param_check = ParamCheck::Strict;
    let error = s.execute("browser.visibility", &p).err().map(|e| e.to_string()).unwrap_or_default();
    assert!(error.contains("`itms`"), "{error}");
}

// ---- Named views and Redefine Sketch (#12499) ----

const CAMERA: fn() -> Value = || json!({"target": [1, 2, 3], "yaw": 0.5, "pitch": -0.6, "distance": 150});

#[test]
fn view_schemas_and_the_key_check_agree() {
    assert_keys(input_schema_for::<ViewSaveParams>(), &["camera", "name"]);
    assert_keys(input_schema_for::<ViewRenameParams>(), &["name", "view"]);
    assert_keys(input_schema_for::<ViewDeleteParams>(), &["view"]);
    assert_keys(input_schema_for::<ViewListParams>(), &[]);
    assert_keys(input_schema_for::<ViewApplyParams>(), &["camera", "view"]);
    assert_keys(input_schema_for::<RedefineSketchParams>(), &["author_path", "frame", "offset", "plane", "sketch"]);
}

/// Each call has one problem the handler already refuses: strict gives its message. The session
/// has a sketch (`1`) and no named view, so a view that must exist is looked for in the second
/// test.
#[test]
fn view_strict_keeps_todays_errors() {
    let long = "n".repeat(129);
    let deep: Vec<u64> = (1..=65).collect();
    assert_strict_keeps_todays_errors(&[
        ("view.save", json!({})),
        ("view.save", json!({"name": "A"})),
        ("view.save", json!({"camera": null})),
        ("view.save", json!({"camera": "front"})),
        ("view.save", json!({"camera": {"target": [0, 0, 0], "yaw": 0, "pitch": 0}})),
        ("view.save", json!({"camera": {"target": [0, 0], "yaw": 0, "pitch": 0, "distance": 5}})),
        ("view.save", json!({"camera": {"target": [0, 0, 0], "yaw": 0, "pitch": 0, "distance": 0}})),
        ("view.save", json!({"camera": {"target": [0, 0, 0], "yaw": 0, "pitch": 0, "distance": -3}})),
        ("view.save", json!({"camera": CAMERA(), "name": long})),
        ("view.rename", json!({})),
        ("view.rename", json!({"name": "B"})),
        ("view.rename", json!({"view": 5, "name": "B"})),
        ("view.rename", json!({"view": null, "name": "B"})),
        ("view.rename", json!({"view": "Nope", "name": "B"})),
        ("view.delete", json!({})),
        ("view.delete", json!({"view": 5})),
        ("view.delete", json!({"view": null})),
        ("view.delete", json!({"view": "Nope"})),
        ("view.apply", json!({})),
        ("view.apply", json!({"view": 5})),
        ("view.apply", json!({"view": null})),
        ("view.apply", json!({"view": "Nope"})),
        ("view.apply", json!({"view": "top", "camera": CAMERA()})),
        ("view.apply", json!({"view": "top", "camera": null})),
        ("view.apply", json!({"camera": null})),
        ("view.apply", json!({"camera": "front"})),
        ("view.apply", json!({"camera": {"target": [0, 0, 0], "yaw": 0, "pitch": 0}})),
        ("view.apply", json!({"camera": {"target": [0, 0, 0], "yaw": 0, "pitch": 0, "distance": 80, "up": "y"}})),
        ("view.apply", json!({"camera": {"target": [0, 0, 0], "yaw": 0, "pitch": 0, "distance": 80, "up": null}})),
        ("view.apply", json!({"camera": {"target": [0, 0, 0], "yaw": 0, "pitch": 0, "distance": 80, "roll": "x"}})),
        ("view.apply", json!({"camera": {"target": [0, 0, 0], "yaw": 0, "pitch": 0, "distance": 80, "roll": null}})),
        ("view.apply", json!({"camera": {"target": [0, 0, 0], "yaw": 0, "pitch": 1.6, "distance": 80}})),
        ("view.apply", json!({"camera": {"target": [0, 0, 0], "yaw": 0, "pitch": -1.6, "distance": 80}})),
        ("view.apply", json!({"camera": {"target": [0, 0, 0], "yaw": 0, "pitch": 0, "distance": 0}})),
        ("view.apply", json!({"camera": {"target": [0, 0, 0], "yaw": 0, "pitch": 0, "distance": 80, "fov": -0.5}})),
        ("sketch.redefine", json!({})),
        ("sketch.redefine", json!({"plane": "XZ"})),
        ("sketch.redefine", json!({"sketch": true, "plane": "XZ"})),
        ("sketch.redefine", json!({"sketch": null, "plane": "XZ"})),
        ("sketch.redefine", json!({"sketch": [1], "plane": "XZ"})),
        ("sketch.redefine", json!({"sketch": 999, "plane": "XZ"})),
        ("sketch.redefine", json!({"sketch": 1})),
        ("sketch.redefine", json!({"sketch": 1, "plane": null})),
        ("sketch.redefine", json!({"sketch": 1, "plane": true})),
        ("sketch.redefine", json!({"sketch": 1, "plane": 1.5})),
        ("sketch.redefine", json!({"sketch": 1, "plane": -1})),
        ("sketch.redefine", json!({"sketch": 1, "plane": {"x_dir": [1, 0, 0]}})),
        ("sketch.redefine", json!({"sketch": 1, "plane": {"x_dir": [1, 0, 0], "y_dir": [2, 0, 0]}})),
        ("sketch.redefine", json!({"sketch": 1, "plane": {"origin": "1 mm", "x_dir": [1, 0, 0], "y_dir": [0, 1, 0]}})),
        ("sketch.redefine", json!({"sketch": 1, "plane": {"face": "x"}})),
        ("sketch.redefine", json!({"sketch": 1, "plane": {"face": [1, 2, 3], "body": "Box"}})),
        ("sketch.redefine", json!({"sketch": 1, "plane": "XZ", "frame": "local"})),
        ("sketch.redefine", json!({"sketch": 1, "plane": "XZ", "frame": 3})),
        ("sketch.redefine", json!({"sketch": 1, "plane": "XZ", "frame": "world"})),
        ("sketch.redefine", json!({"sketch": 1, "plane": "XZ", "author_path": "1"})),
        ("sketch.redefine", json!({"sketch": 1, "plane": "XZ", "author_path": null})),
        ("sketch.redefine", json!({"sketch": 1, "plane": "XZ", "author_path": [0]})),
        ("sketch.redefine", json!({"sketch": 1, "plane": "XZ", "author_path": ["a"]})),
        ("sketch.redefine", json!({"sketch": 1, "plane": "XZ", "author_path": deep})),
    ]);
}

/// The calls that need a named view to get as far as their message.
#[test]
fn view_strict_keeps_todays_errors_for_views() {
    let long = "n".repeat(129);
    let cases = [
        ("view.rename", json!({"view": "Front 2", "name": ""})),
        ("view.rename", json!({"view": "Front 2", "name": "   "})),
        ("view.rename", json!({"view": "Front 2", "name": 5})),
        ("view.rename", json!({"view": "Front 2", "name": null})),
        ("view.rename", json!({"view": "Front 2", "name": long})),
        ("view.rename", json!({"view": "Front 2"})),
        ("view.rename", json!({"view": "Front 2", "name": "Other"})),
    ];
    for (id, p) in cases {
        let run = |level: ParamCheck| {
            let mut s = Session { param_check: level, ..Session::default() };
            for name in ["Front 2", "Other"] {
                s.execute("view.save", &json!({"camera": CAMERA(), "name": name})).unwrap_or_else(|e| panic!("{e}"));
            }
            s.execute(id, &p).err().map(|e| e.to_string())
        };
        let off = run(ParamCheck::Off);
        assert!(off.is_some(), "{id} {p} should fail today");
        assert_eq!(run(ParamCheck::Strict), off, "{id} {p}");
    }
}

/// What the handlers refuse is refused by the types with the same message, and what they take
/// is taken: the check names no problem for any call that works today, in the forms that read
/// different keys (`view` or `camera`) and in each form of `plane`.
#[test]
fn the_check_reads_each_key_as_the_handler_does() {
    let issues = |id: &str, p: Value| crate::schema::issues(id, &p).into_iter().map(|i| i.message).collect::<Vec<_>>();
    let none = Vec::<String>::new();
    let cam = |extra: Value| {
        let mut c = CAMERA();
        c["distance"] = json!(80);
        for (k, v) in extra.as_object().into_iter().flatten() {
            c[k] = v.clone();
        }
        c
    };
    // view.apply: a view, or a camera.
    assert_eq!(issues("view.apply", json!({"view": "top"})), none);
    assert_eq!(issues("view.apply", json!({"view": "Anything"})), none);
    assert_eq!(issues("view.apply", json!({"camera": cam(json!({}))})), none);
    assert_eq!(issues("view.apply", json!({"camera": cam(json!({"fov": 0.5, "roll": 1.0}))})), none);
    assert_eq!(issues("view.apply", json!({"camera": cam(json!({"roll": 100}))})), none, "a roll past π is clamped");
    assert_eq!(issues("view.apply", json!({"camera": cam(json!({"pitch": std::f64::consts::FRAC_PI_2}))})), none);
    // `view` is read as text only: where `camera` is the form, one that is not text is not looked at.
    assert_eq!(issues("view.apply", json!({"view": null, "camera": cam(json!({}))})), none);
    assert_eq!(issues("view.apply", json!({"view": 5, "camera": cam(json!({}))})), none);
    assert_eq!(issues("view.apply", json!({"view": "top", "camera": cam(json!({}))})), ["give `view` or `camera`, not both"]);
    assert_eq!(issues("view.apply", json!({"view": "top", "camera": null})), ["give `view` or `camera`, not both"]);
    assert_eq!(
        issues("view.apply", json!({"camera": cam(json!({"up": "z"}))})),
        ["camera `up` is not supported: the up axis comes from the design settings"]
    );
    assert_eq!(issues("view.apply", json!({"camera": cam(json!({"roll": "x"}))})), ["camera `roll` must be a finite number in radians"]);
    assert_eq!(issues("view.apply", json!({"camera": cam(json!({"pitch": 2}))})), ["camera `pitch` must be within ±π/2 radians (±90°)"]);
    assert_eq!(issues("view.apply", json!({"camera": cam(json!({"distance": 0}))})), ["the camera must be finite with a positive distance"]);
    assert_eq!(issues("view.apply", json!({"camera": cam(json!({"fov": -1}))})), ["the camera must be finite with a positive distance"]);
    assert!(issues("view.apply", json!({"camera": {"yaw": 1}}))[0].starts_with("bad camera: missing field `target`"));
    // Neither: the handler's own message (the type leaves it to the handler).
    assert_eq!(issues("view.apply", json!({})), none);
    // view.save.
    assert_eq!(issues("view.save", json!({"camera": CAMERA()})), none);
    assert_eq!(issues("view.save", json!({"camera": CAMERA(), "name": "  "})), none);
    assert_eq!(issues("view.save", json!({"camera": CAMERA(), "name": null})), none);
    // Not text: the handler reads it as left out; the check reports it.
    assert_eq!(issues("view.save", json!({"camera": CAMERA(), "name": 5})).len(), 1);
    assert_eq!(
        issues("view.save", json!({"camera": {"name": "old", "target": [1, 2, 3], "yaw": 0, "pitch": 7, "distance": 1, "fov": 0.3}, "name": "N"})),
        none
    );
    assert_eq!(issues("view.save", json!({"camera": cam(json!({"distance": -1}))})), ["the camera must be finite with a positive distance"]);
    assert_eq!(issues("view.save", json!({"camera": CAMERA(), "name": "n".repeat(129)})), ["`name` is too long"]);
    assert_eq!(issues("view.save", json!({"camera": CAMERA(), "name": format!("  {}  ", "n".repeat(128))})), none);
    // view.rename and view.delete.
    assert_eq!(issues("view.rename", json!({"view": "a", "name": "b"})), none);
    assert_eq!(issues("view.rename", json!({"view": 1, "name": "b"})), ["`view` must be a view name"]);
    assert_eq!(issues("view.rename", json!({"view": "a", "name": ""})), ["`name` must be 1…128 characters"]);
    assert_eq!(issues("view.delete", json!({"view": null})), ["`view` must be a view name"]);
    assert_eq!(issues("view.list", json!({})), none);
    assert_eq!(issues("view.list", json!({"views": 1})).len(), 1);
    // sketch.redefine: each form of the plane, and `frame` and `author_path` as given.
    let plane = |p: Value| issues("sketch.redefine", json!({"sketch": "S", "plane": p}));
    for p in [
        json!("XY"),
        json!("front"),
        json!("Plane1"),
        json!(7),
        json!({"x_dir": [1, 0, 0], "y_dir": [0, 1, 0]}),
        json!({"origin": [1, 2, 3], "x_dir": [1, 0, 0], "y_dir": [0, 0, 1]}),
        json!({"origin": null, "x_dir": {"x": 1, "y": 0, "z": 0}, "y_dir": [0, 1, 0]}),
        json!({"face": [1, 2, 3]}),
        json!({"face": [1, 2, 3], "body": "Box", "index": 2, "path": [1, 2], "fixed": true}),
    ] {
        assert_eq!(plane(p.clone()), none, "{p}");
    }
    assert_eq!(plane(json!(1.5)).len(), 1);
    assert_eq!(plane(json!(null)), ["`plane` must be XY, XZ, YZ, a construction plane name or id, or an object"]);
    assert_eq!(plane(json!({"x_dir": [1, 0, 0]})), ["plane needs y_dir"]);
    let with = |extra: Value| {
        let mut p = json!({"sketch": 1, "plane": "XZ"});
        for (k, v) in extra.as_object().into_iter().flatten() {
            p[k] = v.clone();
        }
        issues("sketch.redefine", p)
    };
    assert_eq!(with(json!({"offset": 5})), none);
    assert_eq!(with(json!({"offset": "w / 2"})), none);
    assert_eq!(with(json!({"frame": null})), none);
    assert_eq!(with(json!({"frame": "component", "author_path": [1, 2]})), none);
    assert_eq!(with(json!({"author_path": []})), none);
    assert_eq!(with(json!({"frame": "x"})), ["`frame` must be \"world\" or \"component\""]);
    assert_eq!(with(json!({"author_path": [0]})), ["invalid author_path id"]);
    assert_eq!(with(json!({"author_path": null})), ["author_path must contain at most64 ids"]);
    assert_eq!(issues("sketch.redefine", json!({"sketch": 2.5, "plane": "XZ"})), none);
    assert_eq!(issues("sketch.redefine", json!({"sketch": {}, "plane": "XZ"})), ["`sketch` must be an id or name"]);
}

/// The schemas say what the handlers need, and no more.
#[test]
fn the_view_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}");
        }
    };
    let cam = |extra: Value| {
        let mut c = CAMERA();
        for (k, v) in extra.as_object().into_iter().flatten() {
            c[k] = v.clone();
        }
        c
    };
    takes(
        input_schema_for::<ViewSaveParams>(),
        &[
            (json!({"camera": CAMERA()}), true),
            (json!({"camera": cam(json!({"fov": 0.4})), "name": "N"}), true),
            (json!({"name": "N"}), false),
            (json!({"camera": cam(json!({"distance": 0}))}), false),
            (json!({"camera": {"yaw": 0}}), false),
        ],
    );
    takes(
        input_schema_for::<ViewApplyParams>(),
        &[
            (json!({"view": "top"}), true),
            (json!({"camera": cam(json!({"roll": 0.3, "fov": 0.5}))}), true),
            (json!({}), false),
            (json!({"view": "top", "camera": CAMERA()}), false),
            (json!({"camera": cam(json!({"up": "z"}))}), false),
            (json!({"camera": cam(json!({"pitch": 2}))}), false),
            (json!({"camera": cam(json!({"fov": -1}))}), false),
        ],
    );
    takes(
        input_schema_for::<ViewRenameParams>(),
        &[(json!({"view": "a", "name": "b"}), true), (json!({"view": "a"}), false), (json!({"name": "b"}), false)],
    );
    takes(input_schema_for::<ViewDeleteParams>(), &[(json!({"view": "a"}), true), (json!({}), false), (json!({"view": 1}), false)]);
    takes(input_schema_for::<ViewListParams>(), &[(json!({}), true), (json!({"x": 1}), false)]);
    takes(
        input_schema_for::<RedefineSketchParams>(),
        &[
            (json!({"sketch": 3, "plane": "XZ"}), true),
            (
                json!({"sketch": "S", "plane": {"x_dir": [1, 0, 0], "y_dir": [0, 1, 0]}, "frame": "component", "offset": "2 mm", "author_path": [1]}),
                true,
            ),
            (json!({"sketch": "S", "plane": {"face": [1, 2, 3]}}), true),
            (json!({"plane": "XZ"}), false),
            (json!({"sketch": 3}), false),
            (json!({"sketch": 3, "plane": "XZ", "frame": "x"}), false),
            (json!({"sketch": 3, "plane": "XZ", "author_path": [0]}), false),
        ],
    );
}

/// Every form of the six commands, in Warn: each real reply matches its output schema and
/// carries no warning, and the replies are the JSON the handlers have always returned.
#[test]
fn view_and_redefine_replies_match_the_output_schema() {
    let mut s = Session { param_check: ParamCheck::Warn, ..Session::default() };
    let mut run = |id: &str, p: Value, schema: schemars::Schema| {
        let r = s.execute(id, &p).unwrap_or_else(|e| panic!("{id} {p}: {e}"));
        let schema = schema.as_value();
        assert!(r.get("param_warnings").is_none(), "{id} {p}: {r}");
        assert!(conforms(schema, schema, &r), "{id} {p}: {r} doesn't match {schema}");
        r
    };
    let saved = run("view.save", json!({"camera": CAMERA()}), output_schema_for::<ViewSaved>());
    assert_eq!(saved, json!({"view": "Named View1"}));
    let saved = run(
        "view.save",
        json!({"camera": {"target": [1, 2, 3], "yaw": 0, "pitch": 0.2, "distance": 9, "fov": 0.4}, "name": " Detail "}),
        output_schema_for::<ViewSaved>(),
    );
    assert_eq!(saved, json!({"view": "Detail"}));
    run("view.save", json!({"camera": CAMERA(), "name": null}), output_schema_for::<ViewSaved>());
    let listed = run("view.list", json!({}), output_schema_for::<ViewListResult>());
    assert_eq!(listed["views"].as_array().map(Vec::len), Some(3), "{listed}");
    assert_eq!(listed["views"][1]["name"], "Detail", "{listed}");
    let schema = output_schema_for::<ViewListResult>();
    let entry = &listed["views"][0];
    assert!(entry["target"].is_array() && entry["fov"] == 0.0 && entry["distance"] == 150.0, "{listed}");
    assert!(conforms(schema.as_value(), schema.as_value(), &listed));
    let renamed = run("view.rename", json!({"view": "Named View1", "name": " Overview "}), output_schema_for::<ViewRenamed>());
    assert_eq!(renamed, json!({"view": "Overview"}));
    let deleted = run("view.delete", json!({"view": "Overview"}), output_schema_for::<ViewDeleted>());
    assert_eq!(deleted, json!({"deleted": "Overview"}));
    let empty = run("view.list", json!({}), output_schema_for::<ViewListResult>());
    assert_eq!(empty["views"].as_array().map(Vec::len), Some(2), "{empty}");

    let camera = output_schema_for::<CameraReply>;
    for view in ["front", "back", "top", "iso", "home"] {
        run("view.apply", json!({"view": view}), camera());
    }
    let named = run("view.apply", json!({"view": "Detail"}), camera());
    assert!((named["camera"]["pitch"].as_f64().unwrap_or_default() - 0.2).abs() < 1e-12, "{named}");
    let turned =
        run("view.apply", json!({"camera": {"target": [0, 0, 0], "yaw": 1, "pitch": 0.2, "distance": 80, "fov": 0.5, "roll": 1.0}}), camera());
    assert_eq!(turned["camera"]["roll"], 1.0, "{turned}");
    let clamped = run("view.apply", json!({"camera": {"target": [0, 0, 0], "yaw": 1, "pitch": 0.2, "distance": 80, "roll": 100}}), camera());
    assert!((clamped["camera"]["roll"].as_f64().unwrap_or_default() - std::f64::consts::PI).abs() < 1e-12, "{clamped}");
    run("view.apply", json!({"camera": {"target": [0, 0, 0], "yaw": 0, "pitch": std::f64::consts::FRAC_PI_2, "distance": 80}}), camera());

    // Redefine Sketch: a sketch, moved to a named plane, offset, an explicit plane in each frame,
    // and a face of a body.
    let sketch = |s: &mut Session| s.execute("sketch.create", &json!({"plane": "XY"})).unwrap_or_else(|e| panic!("{e}"))["sketch"].clone();
    let sk = sketch(&mut s);
    let mut run = |id: &str, p: Value| {
        let r = s.execute(id, &p).unwrap_or_else(|e| panic!("{id} {p}: {e}"));
        let schema = output_schema_for::<RedefineSketchResult>();
        assert!(r.get("param_warnings").is_none(), "{id} {p}: {r}");
        assert!(conforms(schema.as_value(), schema.as_value(), &r), "{id} {p}: {r}");
        assert!(r["created"].is_object(), "the session adds `created`: {r}");
        let mut r = r;
        r.as_object_mut().map(|o| o.remove("created"));
        r
    };
    let r = run("sketch.redefine", json!({"sketch": sk, "plane": "XZ"}));
    assert_eq!(r, json!({"sketch": sk, "attachment": "fixed"}));
    let r = run("sketch.redefine", json!({"sketch": sk.to_string(), "plane": "YZ", "offset": "5 mm", "frame": null}));
    assert_eq!(r, json!({"sketch": sk, "attachment": "fixed"}));
    let explicit = json!({"origin": [1, 2, 3], "x_dir": [1, 0, 0], "y_dir": [0, 0, 1]});
    let r = run("sketch.redefine", json!({"sketch": sk, "plane": explicit}));
    assert_eq!(r, json!({"sketch": sk, "attachment": "fixed", "frame": "world"}));
    let r = run("sketch.redefine", json!({"sketch": sk, "plane": explicit, "frame": "component"}));
    assert_eq!(r, json!({"sketch": sk, "attachment": "fixed", "frame": "component"}));
}

/// A face of a body that comes before the sketch: the sketch follows it, or stays where the face
/// is now with `fixed`.
#[test]
fn redefine_sketch_onto_a_face_matches_the_output_schema() {
    let mut s = Session { param_check: ParamCheck::Warn, ..Session::default() };
    s.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10, "body_name": "Box"})).unwrap_or_else(|e| panic!("{e}"));
    let sk = s.execute("sketch.create", &json!({"plane": "XY"})).unwrap_or_else(|e| panic!("{e}"))["sketch"].clone();
    let mut run = |p: Value| {
        let r = s.execute("sketch.redefine", &p).unwrap_or_else(|e| panic!("{p}: {e}"));
        let schema = output_schema_for::<RedefineSketchResult>();
        assert!(r.get("param_warnings").is_none() && conforms(schema.as_value(), schema.as_value(), &r), "{p}: {r}");
        r
    };
    let r = run(json!({"sketch": sk, "plane": {"face": [5, 5, 10]}}));
    assert_eq!(r["attachment"], "exact_face", "{r}");
    let r = run(json!({"sketch": sk, "plane": {"face": [5, 5, 10], "body": "Box", "index": 0, "fixed": true}}));
    assert_eq!(r["attachment"], "fixed", "{r}");
}

/// A moved component: a world plane put into it says so in `note`, which the schema describes.
#[test]
fn redefine_sketch_note_matches_the_output_schema() {
    let mut s = Session { param_check: ParamCheck::Warn, ..Session::default() };
    let mut run = |id: &str, p: Value| s.execute(id, &p).unwrap_or_else(|e| panic!("{id} {p}: {e}"));
    let part = run("component.create", json!({"name": "Part", "grounded": false}));
    let sk = run("sketch.create", json!({"plane": "XY"}))["sketch"].clone();
    run("occurrence.move", json!({"occurrence": part["occurrence"], "translate": [10, 0, 0]}));
    let r = run("sketch.redefine", json!({"sketch": sk, "plane": {"x_dir": [1, 0, 0], "y_dir": [0, 1, 0]}, "author_path": [part["occurrence"]]}));
    let schema = output_schema_for::<RedefineSketchResult>();
    assert!(conforms(schema.as_value(), schema.as_value(), &r), "{r}");
    assert!(r.get("param_warnings").is_none(), "{r}");
    assert_eq!(r["frame"], "world", "{r}");
    assert!(r["note"].as_str().is_some_and(|n| n.contains("world coordinates")), "{r}");
}

/// A misspelt key still runs in Warn, and says so, with a reply that matches; Strict refuses it.
#[test]
fn a_misspelt_key_is_reported_for_each_view_command() {
    let mut s = Session::default();
    s.execute("view.save", &json!({"camera": CAMERA(), "name": "V"})).unwrap_or_else(|e| panic!("{e}"));
    let sk = s.execute("sketch.create", &json!({"plane": "XY"})).unwrap_or_else(|e| panic!("{e}"))["sketch"].clone();
    s.param_check = ParamCheck::Warn;
    let cases: Vec<(&str, Value, &str, schemars::Schema)> = vec![
        ("view.apply", json!({"view": "top", "camra": 1}), "camra", output_schema_for::<CameraReply>()),
        ("view.list", json!({"view": "V"}), "view", output_schema_for::<ViewListResult>()),
        ("view.rename", json!({"view": "V", "name": "W", "nmae": 1}), "nmae", output_schema_for::<ViewRenamed>()),
        ("view.save", json!({"camera": CAMERA(), "name": "X", "nmae": 1}), "nmae", output_schema_for::<ViewSaved>()),
        ("sketch.redefine", json!({"sketch": sk, "plane": "XZ", "frme": "world"}), "frme", output_schema_for::<RedefineSketchResult>()),
        ("view.delete", json!({"view": "X", "vew": 1}), "vew", output_schema_for::<ViewDeleted>()),
    ];
    for (id, p, key, schema) in cases {
        let r = s.execute(id, &p).unwrap_or_else(|e| panic!("{id} {p}: {e}"));
        assert!(r["param_warnings"].to_string().contains(key), "{id}: {r}");
        assert!(conforms(schema.as_value(), schema.as_value(), &r), "{id}: {r}");
    }
    s.param_check = ParamCheck::Strict;
    let error = s.execute("view.apply", &json!({"view": "top", "camra": 1})).err().map(|e| e.to_string()).unwrap_or_default();
    assert!(error.contains("`camra`"), "{error}");
}

/// The commands run exactly as before with the check off, whatever the call (the types only
/// describe).
#[test]
fn the_view_commands_still_read_their_calls_as_before_with_the_check_off() {
    let mut s = Session::default();
    s.execute("view.save", &json!({"camera": CAMERA(), "name": 5})).unwrap_or_else(|e| panic!("{e}"));
    assert_eq!(s.execute("view.list", &json!({"x": 1})).unwrap_or_else(|e| panic!("{e}"))["views"][0]["name"], "Named View1");
    s.execute("view.apply", &json!({"view": 5, "camera": CAMERA()})).unwrap_or_else(|e| panic!("{e}"));
}