Skip to content

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

30.1 KB
Raw Blame
use serde_json::{Value, json};
use solidcraft_doc::FeatureKind;
use solidcraft_doc::frame::{self, MAX_MEMBERS};

use super::{
    FrameMemberParams, ProfileInsertParams, ProfileInsertResult, ProfileListParams, ProfileListResult, ProfilePropertiesParams,
    ProfilePropertiesResult,
};
use crate::Session;
use crate::schema::features::FeatureResult;
use crate::schema::tests::{assert_keys, assert_strict_keeps_todays_errors, conforms, sketch_rectangle};
use crate::schema::{ParamCheck, input_schema_for, issues, output_schema_for};

fn tube() -> Value {
    json!({"kind": "rect_tube", "width": 40, "height": 40, "wall": 3})
}

/// The id of the first sketch of `s`.
fn first_sketch(s: &Session) -> u64 {
    s.doc.features.iter().find(|f| matches!(f.kind, FeatureKind::Sketch { .. })).map(|f| f.id).unwrap_or_else(|| panic!("no sketch"))
}

/// A session with the 600 × 400 rectangle `Frame` (its four line ids returned) and the sketch
/// `Section`, two concentric circles: a tube's wall.
fn frame_session(level: ParamCheck) -> (Session, Vec<String>) {
    let mut s = Session { param_check: level, ..Session::default() };
    let mut run = |id: &str, p: Value| s.execute(id, &p).unwrap_or_else(|e| panic!("{id} {p}: {e}"));
    run("sketch.create", json!({"plane": "XY", "name": "Frame"}));
    let rectangle = run("sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [600, 400]}));
    run("sketch.finish", json!({}));
    run("sketch.create", json!({"plane": "XY", "name": "Section"}));
    run("sketch.circle.center", json!({"center": [0, 0], "radius": 20}));
    run("sketch.circle.center", json!({"center": [0, 0], "radius": 17}));
    run("sketch.finish", json!({}));
    let lines =
        rectangle["created"]["curves"].as_array().map(|c| c.iter().filter_map(|c| c.as_str().map(str::to_string)).collect()).unwrap_or_default();
    (s, lines)
}

#[test]
fn schemas_and_the_key_check_agree() {
    assert_keys(
        input_schema_for::<FrameMemberParams>(),
        &[
            "anchor",
            "angle",
            "body_name",
            "exact_regions",
            "lines",
            "mirror",
            "name",
            "names",
            "participants",
            "profile",
            "profile_sketch",
            "profiles",
            "sketch",
        ],
    );
    assert_keys(input_schema_for::<ProfileListParams>(), &[]);
    assert_keys(input_schema_for::<ProfilePropertiesParams>(), &["density", "profile"]);
    assert_keys(input_schema_for::<ProfileInsertParams>(), &["anchor", "angle", "at", "fixed", "profile", "sketch"]);
}

#[test]
fn strict_keeps_todays_errors() {
    let sketch = {
        let mut s = Session::default();
        sketch_rectangle(&mut s);
        first_sketch(&s)
    };
    let member = |extra: Value| {
        let mut p = json!({"sketch": sketch, "profile": tube()});
        for (k, v) in extra.as_object().into_iter().flatten() {
            p[k] = v.clone();
        }
        ("frame.member", p)
    };
    let bar = json!({"kind": "round_bar", "diameter": 10});
    let insert = |extra: Value| {
        let mut p = json!({"profile": bar});
        for (k, v) in extra.as_object().into_iter().flatten() {
            p[k] = v.clone();
        }
        ("frame.profile.insert", p)
    };
    assert_strict_keeps_todays_errors(&[
        // frame.member
        ("frame.member", json!({})),
        ("frame.member", json!({"sketch": null, "profile": tube()})),
        ("frame.member", json!({"sketch": true, "profile": tube()})),
        ("frame.member", json!({"sketch": [1], "profile": tube()})),
        ("frame.member", json!({"sketch": sketch})),
        ("frame.member", json!({"sketch": sketch, "profile": tube(), "profile_sketch": sketch})),
        ("frame.member", json!({"sketch": sketch, "profile": tube(), "profile_sketch": null})),
        ("frame.member", json!({"sketch": sketch, "profile_sketch": true})),
        ("frame.member", json!({"sketch": sketch, "profile_sketch": null})),
        ("frame.member", json!({"sketch": sketch, "profile_sketch": sketch})),
        ("frame.member", json!({"sketch": sketch, "profile_sketch": "Nowhere"})),
        ("frame.member", json!({"sketch": sketch, "profile_sketch": 99999, "profiles": 3})),
        ("frame.member", json!({"sketch": "Nowhere", "profile": tube()})),
        member(json!({"profile": null})),
        member(json!({"profile": "tube"})),
        member(json!({"profile": {}})),
        member(json!({"profile": {"kind": "hexagon"}})),
        member(json!({"profile": {"kind": 5}})),
        member(json!({"profile": {"kind": "bar", "width": 10}})),
        member(json!({"profile": {"kind": "bar", "width": 10, "height": 5, "diameter": 3}})),
        member(json!({"profile": {"kind": "bar", "width": true, "height": 5}})),
        member(json!({"profile": {"kind": "bar", "width": " ", "height": 5}})),
        member(json!({"profile": {"kind": "rect_tube", "width": 10, "height": 10, "wall": 5}})),
        member(json!({"profile": {"kind": "bar", "width": "nonsense(", "height": 5}})),
        member(json!({"lines": []})),
        member(json!({"lines": "l1"})),
        member(json!({"lines": [1]})),
        member(json!({"lines": ["l1", "l1"]})),
        member(json!({"lines": (0..=MAX_MEMBERS).map(|i| format!("l{i}")).collect::<Vec<_>>()})),
        member(json!({"lines": ["nope"]})),
        member(json!({"body_name": ""})),
        member(json!({"body_name": "   "})),
        member(json!({"body_name": 5})),
        member(json!({"body_name": "x".repeat(129)})),
        member(json!({"anchor": "middle"})),
        member(json!({"anchor": 5})),
        member(json!({"anchor": ["top"]})),
        member(json!({"angle": true})),
        member(json!({"angle": ""})),
        member(json!({"angle": "x".repeat(4097)})),
        member(json!({"angle": "a lot"})),
        member(json!({"mirror": 3})),
        member(json!({"mirror": "yes"})),
        member(json!({"names": ["Rail"]})),
        member(json!({"names": {"l1": " "}})),
        member(json!({"names": {"l1": 5}})),
        member(json!({"names": {"l1": "x".repeat(129)}})),
        member(json!({"participants": 5})),
        member(json!({"participants": [5]})),
        member(json!({"participants": ["Nobody"]})),
        // frame.profile.properties
        ("frame.profile.properties", json!({})),
        ("frame.profile.properties", json!({"profile": null})),
        ("frame.profile.properties", json!({"profile": {"kind": "hexagon"}})),
        ("frame.profile.properties", json!({"profile": {"kind": "round_bar"}})),
        ("frame.profile.properties", json!({"profile": {"kind": "round_bar", "diameter": -1}})),
        ("frame.profile.properties", json!({"profile": bar, "density": -1})),
        ("frame.profile.properties", json!({"profile": bar, "density": 0})),
        ("frame.profile.properties", json!({"profile": bar, "density": "steel"})),
        ("frame.profile.properties", json!({"profile": bar, "density": 1e7})),
        ("frame.profile.properties", json!({"profile": bar, "density": true})),
        // frame.profile.insert
        ("frame.profile.insert", json!({})),
        ("frame.profile.insert", json!({"profile": {"kind": "bar", "width": 5}})),
        insert(json!({"at": "here"})),
        insert(json!({"at": [1]})),
        insert(json!({"at": [1e300, 0]})),
        insert(json!({"at": {"x": 1}})),
        insert(json!({"anchor": "middle"})),
        insert(json!({"anchor": 3})),
        insert(json!({"angle": "a lot"})),
        insert(json!({"angle": 1e7})),
        insert(json!({"fixed": 3})),
        insert(json!({"fixed": "false"})),
        insert(json!({"sketch": true})),
        insert(json!({"sketch": -1})),
        insert(json!({"sketch": 1.5})),
        insert(json!({"sketch": "Nowhere"})),
        // No sketch is being edited, and none is named.
        insert(json!({})),
    ]);
}

/// Each key is read as its handler reads it: a call the handler takes has no issue, and a call
/// it refuses over a key has one. (A call with a key the handler ignores is told apart below.)
#[test]
fn the_types_read_each_key_as_the_handlers_do() {
    let (_, lines) = frame_session(ParamCheck::Off);
    let line = lines.first().cloned().unwrap_or_default();
    let member = |extra: Value| {
        let mut p = json!({"sketch": "Frame", "profile": tube()});
        for (k, v) in extra.as_object().into_iter().flatten() {
            p[k] = v.clone();
        }
        p
    };
    let section = |extra: Value| {
        let mut p = json!({"sketch": "Frame", "profile_sketch": "Section"});
        for (k, v) in extra.as_object().into_iter().flatten() {
            p[k] = v.clone();
        }
        p
    };
    // (call, whether the handler takes it)
    let cases = [
        (member(json!({})), true),
        (member(json!({"lines": [line]})), true),
        (member(json!({"lines": null})), true),
        (member(json!({"lines": []})), false),
        (member(json!({"lines": [line, line]})), false),
        (member(json!({"body_name": "Rail"})), true),
        (member(json!({"body_name": "  Rail  "})), true),
        (member(json!({"body_name": null})), true),
        (member(json!({"body_name": "x".repeat(128)})), true),
        (member(json!({"body_name": "x".repeat(129)})), false),
        (member(json!({"body_name": " "})), false),
        (member(json!({"anchor": "bottom_left"})), true),
        (member(json!({"anchor": null})), true),
        (member(json!({"anchor": "Top"})), false),
        (member(json!({"angle": "90 deg"})), true),
        (member(json!({"angle": 45})), true),
        (member(json!({"angle": " 30 deg "})), true),
        (member(json!({"angle": null})), true),
        (member(json!({"angle": ""})), false),
        (member(json!({"angle": 1e9})), false),
        (member(json!({"mirror": true})), true),
        (member(json!({"mirror": null})), true),
        (member(json!({"mirror": 1})), false),
        (member(json!({"names": {line.clone(): " Mine "}})), true),
        (member(json!({"names": {}})), true),
        (member(json!({"names": null})), true),
        (member(json!({"names": {line.clone(): ""}})), false),
        (member(json!({"names": [line]})), false),
        (member(json!({"name": "Frame members"})), true),
        (member(json!({"participants": "*"})), true),
        (member(json!({"participants": ["*"]})), true),
        (member(json!({"participants": null})), true),
        (member(json!({"participants": [3]})), false),
        (member(json!({"participants": {"a": 1}})), false),
        (member(json!({"profile": {"kind": "bar", "width": "40 mm", "height": 10, "corner_radius": 0}})), true),
        (member(json!({"profile": {"kind": "bar", "width": 40}})), false),
        (member(json!({"profile": {"kind": "i_beam", "height": 100, "width": 50, "web": 4.5, "flange": 7, "root_radius": null}})), false),
        (section(json!({})), true),
        (section(json!({"profiles": "all"})), true),
        (section(json!({"profiles": [{"point": [0, 0]}], "exact_regions": true})), true),
        (section(json!({"profiles": [0]})), true),
        (section(json!({"profiles": "none"})), false),
        (section(json!({"profiles": null})), false),
        (section(json!({"profiles": []})), false),
        // Keys the handler never reads in this form: no issue, and the call is as good as without.
        (member(json!({"profiles": "none", "exact_regions": "yes"})), true),
        (member(json!({"profiles": null})), true),
    ];
    for (p, takes) in cases {
        let (mut s, _) = frame_session(ParamCheck::Off);
        let outcome = s.execute("frame.member", &p);
        assert_eq!(outcome.is_ok(), takes, "{p}: {outcome:?}");
        assert_eq!(issues("frame.member", &p).is_empty(), takes, "{p}: {:?}", issues("frame.member", &p));
    }

    // One of `profile` and `profile_sketch`: with both or neither the handler refuses before it
    // reads the section's keys, and the check, which can't see the design, leaves it that.
    for p in [
        json!({"sketch": "Frame", "profile": tube(), "profile_sketch": "Section"}),
        json!({"sketch": "Frame", "profile": tube(), "profile_sketch": "Section", "profiles": "none", "exact_regions": 1}),
        json!({"sketch": "Frame", "profile": null, "profile_sketch": null}),
        json!({"sketch": "Frame"}),
        json!({"sketch": "Frame", "profiles": "none"}),
    ] {
        let (mut s, _) = frame_session(ParamCheck::Off);
        let error = s.execute("frame.member", &p).unwrap_err().to_string();
        assert!(error.contains("`profile`") && error.contains("one of them"), "{p}: {error}");
        assert!(issues("frame.member", &p).is_empty(), "{p}: {:?}", issues("frame.member", &p));
    }

    // The properties and insert commands.
    let (mut s, _) = frame_session(ParamCheck::Off);
    let bar = json!({"kind": "round_bar", "diameter": 10});
    for (p, takes) in [
        (json!({"profile": bar}), true),
        (json!({"profile": bar, "density": 7850}), true),
        (json!({"profile": bar, "density": null}), true),
        (json!({"profile": bar, "density": 1e6}), true),
        (json!({"profile": bar, "density": 1e6 + 1.0}), false),
        (json!({"profile": bar, "density": 0}), false),
        (json!({"profile": bar, "density": "7850"}), false),
    ] {
        let outcome = s.execute("frame.profile.properties", &p);
        assert_eq!(outcome.is_ok(), takes, "{p}: {outcome:?}");
        assert_eq!(issues("frame.profile.properties", &p).is_empty(), takes, "{p}");
    }
    s.execute("sketch.create", &json!({"plane": "XY"})).unwrap_or_else(|e| panic!("{e}"));
    for (p, takes) in [
        (json!({"profile": bar}), true),
        (json!({"profile": bar, "at": [3, 4], "anchor": "centroid", "angle": 0.5, "fixed": false}), true),
        (json!({"profile": bar, "at": {"x": 3, "y": 4}}), true),
        (json!({"profile": bar, "at": null, "anchor": null, "angle": null, "fixed": null, "sketch": null}), true),
        (json!({"profile": bar, "angle": -1e6}), true),
        (json!({"profile": bar, "angle": 1e6 + 1.0}), false),
        (json!({"profile": bar, "at": [1, 2, 3]}), false),
        (json!({"profile": bar, "fixed": 0}), false),
        (json!({"profile": bar, "anchor": "CENTER"}), false),
        (json!({"profile": bar, "sketch": 1.5}), false),
    ] {
        let outcome = s.execute("frame.profile.insert", &p);
        assert_eq!(outcome.is_ok(), takes, "{p}: {outcome:?}");
        assert_eq!(issues("frame.profile.insert", &p).is_empty(), takes, "{p}");
    }
}

/// With a built-in profile, a `profiles` or `exact_regions` that couldn't be read is no warning;
/// with a profile sketch it is, and says what the handler says.
#[test]
fn a_section_sketchs_keys_count_only_with_a_section_sketch() {
    let messages = |p: Value| issues("frame.member", &p).into_iter().map(|i| i.message).collect::<Vec<_>>();
    assert_eq!(messages(json!({"sketch": 1, "profile": tube(), "profiles": 7, "exact_regions": []})), Vec::<String>::new());
    assert_eq!(messages(json!({"sketch": 1, "profile_sketch": 2, "profiles": "none"})), ["`profiles` must be \"all\" or a list"]);
    assert_eq!(messages(json!({"sketch": 1, "profile_sketch": 2, "exact_regions": "yes"})), ["`exact_regions` must be true or false"]);
}

/// The schemas say what the handlers need: `sketch` and a profile are required, `profile` and
/// `profile_sketch` are alternatives, and values have the shape the handlers read.
#[test]
fn the_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 bar = json!({"kind": "round_bar", "diameter": 10});
    takes(
        input_schema_for::<FrameMemberParams>(),
        &[
            (json!({"sketch": "Frame", "profile": tube()}), true),
            (json!({"sketch": 3, "profile_sketch": "Section"}), true),
            (json!({"sketch": 3, "profile_sketch": 4, "profiles": [{"point": [0, 0]}], "exact_regions": true}), true),
            (
                json!({
                    "sketch": "Frame", "lines": ["l1", "l2"], "profile": {"kind": "bar", "width": "w", "height": 5, "corner_radius": 1},
                    "anchor": "top_left", "angle": "90 deg", "mirror": true, "name": "N", "body_name": "Rail",
                    "names": {"l1": "A"}, "participants": ["*"]
                }),
                true,
            ),
            (json!({"profile": tube()}), false),
            (json!({"sketch": "Frame"}), false),
            (json!({"sketch": "Frame", "profile": tube(), "profile_sketch": "Section"}), false),
            (json!({"sketch": "Frame", "profile": {"kind": "hexagon"}}), false),
            (json!({"sketch": "Frame", "profile": {"kind": "bar", "width": 5}}), false),
            (json!({"sketch": "Frame", "profile": {"kind": "bar", "width": 5, "height": 5, "wall": 1}}), false),
            (json!({"sketch": true, "profile": tube()}), false),
            (json!({"sketch": "Frame", "profile": tube(), "lines": []}), false),
            (json!({"sketch": "Frame", "profile": tube(), "lines": ["a", "a"]}), false),
            (json!({"sketch": "Frame", "profile": tube(), "anchor": "middle"}), false),
            (json!({"sketch": "Frame", "profile": tube(), "angle": true}), false),
            (json!({"sketch": "Frame", "profile": tube(), "body_names": ["a"]}), false),
        ],
    );
    takes(input_schema_for::<ProfileListParams>(), &[(json!({}), true), (json!({"kind": "bar"}), false)]);
    takes(
        input_schema_for::<ProfilePropertiesParams>(),
        &[
            (json!({"profile": bar}), true),
            (json!({"profile": bar, "density": 7850}), true),
            (json!({"profile": bar, "density": null}), true),
            (json!({"profile": bar, "density": 0}), false),
            (json!({"profile": bar, "density": 1e6 + 1.0}), false),
            (json!({"density": 7850}), false),
            (json!({"profile": {"kind": "round_bar"}}), false),
        ],
    );
    takes(
        input_schema_for::<ProfileInsertParams>(),
        &[
            (json!({"profile": bar}), true),
            (json!({"profile": bar, "at": [1, 2], "anchor": "bottom", "angle": 2.5, "fixed": false, "sketch": "S"}), true),
            (json!({"profile": bar, "at": {"x": 1, "y": 2}, "sketch": 4}), true),
            (json!({}), false),
            (json!({"profile": bar, "at": [1, 2, 3]}), false),
            (json!({"profile": bar, "angle": 2e6}), false),
            (json!({"profile": bar, "fixed": "yes"}), false),
            (json!({"profile": bar, "sketch": 1.5}), false),
        ],
    );
}

/// The "not blank" patterns are the shared one, which `conforms` doesn't read: pin where they are.
#[test]
fn the_name_patterns_are_the_blank_pattern() {
    let blank = crate::schema::types::not_blank_pattern();
    let member = input_schema_for::<FrameMemberParams>();
    let member = member.as_value();
    assert_eq!(member["properties"]["body_name"]["anyOf"][0]["$ref"], json!("#/$defs/MemberName"));
    assert_eq!(member["$defs"]["MemberName"]["pattern"], json!(blank));
    assert_eq!(member["$defs"]["MemberNames"]["additionalProperties"]["pattern"], json!(blank));
    let properties = input_schema_for::<ProfilePropertiesParams>();
    let properties = properties.as_value();
    let kinds = properties["$defs"]["ProfileParam"]["anyOf"].as_array().cloned().unwrap_or_default();
    assert_eq!(kinds.len(), frame::profile_kinds().len());
    assert_eq!(kinds[0]["properties"]["width"]["anyOf"][1]["pattern"], json!(blank));
}

/// The warning for what a key gets wrong, and the check that every built-in kind is described.
#[test]
fn the_check_names_what_is_wrong_with_a_key() {
    let issues = |id: &str, p: Value| crate::schema::issues(id, &p).into_iter().map(|i| i.message).collect::<Vec<_>>();
    assert_eq!(issues("frame.profile.properties", json!({"profile": {"kind": "hexagon"}})).len(), 1);
    assert_eq!(
        issues("frame.profile.properties", json!({"profile": {"kind": "bar", "width": 1, "height": 1, "wall": 1}})),
        ["`profile`: a bar profile has no dimension `wall`"]
    );
    assert_eq!(issues("frame.profile.properties", json!({"profile": {"kind": "bar"}})), ["`profile`: a bar profile needs `width`"]);
    assert_eq!(
        issues("frame.profile.properties", json!({"profile": {"kind": "round_bar", "diameter": 1}, "density": -3})),
        ["`density` must be a positive number of kg/m³ (at most 1e6)"]
    );
    assert_eq!(
        issues("frame.profile.insert", json!({"profile": {"kind": "round_bar", "diameter": 1}, "at": 3})),
        ["`at` must be [x, y] in sketch millimetres"]
    );
    assert_eq!(
        issues("frame.profile.insert", json!({"profile": {"kind": "round_bar", "diameter": 1}, "fixed": "no"})),
        ["`fixed` must be true or false"]
    );
    assert_eq!(issues("frame.member", json!({"sketch": 1, "profile": tube(), "mirror": "no"})), ["`mirror` must be true or false"]);
    assert_eq!(issues("frame.member", json!({"sketch": 1, "profile": tube(), "lines": ["a", "a"]})), ["line `a` is listed twice"]);
    assert_eq!(
        issues("frame.member", json!({"sketch": 1, "profile": tube(), "body_names": ["a"]})),
        ["unknown key `body_names`; did you mean `body_name`?"]
    );
    // The schemas describe every built-in kind with its dimensions, and its example is one.
    let schema = input_schema_for::<ProfilePropertiesParams>();
    let schema = schema.as_value();
    for kind in frame::profile_kinds() {
        let example = serde_json::to_value(&kind.example).unwrap_or_default();
        let profile = json!({"profile": example});
        assert!(conforms(schema, schema, &profile), "{profile}");
        assert!(crate::schema::issues("frame.profile.properties", &profile).is_empty(), "{profile}");
    }
}

fn matches(schema: schemars::Schema, id: &str, reply: &Value) {
    let schema = schema.as_value();
    assert!(conforms(schema, schema, reply), "{id}: {reply} doesn't match {schema}");
    assert!(reply.get("param_warnings").is_none(), "{id}: {reply}");
}

/// The library's list and properties replies match the output schemas and are what the handlers
/// built before the typed replies: the same JSON.
#[test]
fn profile_library_replies_match_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 listed = run("frame.profile.list", json!({}));
    matches(output_schema_for::<ProfileListResult>(), "frame.profile.list", &listed);
    assert_eq!(listed, json!({"kinds": frame::profile_kinds()}));
    let kinds = listed["kinds"].as_array().cloned().unwrap_or_default();
    assert_eq!(kinds.len(), 7);
    for kind in &kinds {
        let r = run("frame.profile.properties", json!({"profile": kind["example"]}));
        matches(output_schema_for::<ProfilePropertiesResult>(), "frame.profile.properties", &r);
        let profile: frame::Profile = serde_json::from_value(kind["example"].clone()).unwrap_or_else(|e| panic!("{e}"));
        let region = profile.region().unwrap_or_else(|e| panic!("{e}"));
        let sec = frame::section(&region);
        assert_eq!(
            r,
            json!({
                "profile": profile.filled(), "area": sec.area, "centroid": sec.centroid, "ixx": sec.ixx, "iyy": sec.iyy, "ixy": sec.ixy,
                "width": sec.width, "height": sec.height
            })
        );
    }
    let heavy = run("frame.profile.properties", json!({"profile": tube(), "density": 7850}));
    matches(output_schema_for::<ProfilePropertiesResult>(), "frame.profile.properties", &heavy);
    let area = heavy["area"].as_f64().unwrap_or_default();
    assert_eq!(heavy["mass_per_m"], json!(area * 1e-6 * 7850.0), "{heavy}");
    assert_eq!(heavy["profile"]["outer_radius"], json!(6.0), "{heavy}");
    // Dimensions as expressions, in a design with parameters.
    run("parameters.add", json!({"name": "wall", "expression": "3 mm"}));
    let by_parameter =
        run("frame.profile.properties", json!({"profile": {"kind": "rect_tube", "width": "40 mm", "height": 40, "wall": "wall"}, "density": null}));
    matches(output_schema_for::<ProfilePropertiesResult>(), "frame.profile.properties", &by_parameter);
    assert_eq!(by_parameter["area"], run("frame.profile.properties", json!({"profile": tube()}))["area"]);

    // A misspelt key still runs in Warn and says so, with a reply that matches.
    for (id, p) in [("frame.profile.list", json!({"kinds": true})), ("frame.profile.properties", json!({"profile": tube(), "densty": 7850}))] {
        let warned = run(id, p);
        assert!(warned["param_warnings"].as_array().is_some_and(|w| w.len() == 1), "{warned}");
        let schema =
            if id == "frame.profile.list" { output_schema_for::<ProfileListResult>() } else { output_schema_for::<ProfilePropertiesResult>() };
        assert!(conforms(schema.as_value(), schema.as_value(), &warned), "{warned}");
    }
}

/// Insert a profile in every form, in Warn: each reply matches its output schema, carries no
/// warning and is what the handler built before.
#[test]
fn insert_replies_match_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 made = run("sketch.create", json!({"plane": "XY", "name": "Drawing"}));
    let id = made["sketch"].clone();
    let plain = run("frame.profile.insert", json!({"profile": tube()}));
    matches(output_schema_for::<ProfileInsertResult>(), "frame.profile.insert", &plain);
    assert_eq!(plain["created"]["curves"].as_array().map(Vec::len), Some(16), "{plain}");
    assert!(plain["sketch"]["solved"].is_boolean() && plain["sketch"]["dof"].is_u64(), "{plain}");
    let mut keys: Vec<&String> = plain.as_object().map(|o| o.keys().collect()).unwrap_or_default();
    keys.sort();
    assert_eq!(keys, ["created", "section", "sketch"]);
    let mut created: Vec<&String> = plain["created"].as_object().map(|o| o.keys().collect()).unwrap_or_default();
    created.sort();
    assert_eq!(created, ["constraints", "curves", "dimensions", "points"]);
    let section = run("frame.profile.properties", json!({"profile": tube()}));
    // The section is what the library computes for the profile, not just what the other command says.
    let profile: frame::Profile = serde_json::from_value(tube()).unwrap_or_else(|e| panic!("{e}"));
    let sec = frame::section(&profile.region().unwrap_or_else(|e| panic!("{e}")));
    assert_eq!(plain["section"]["area"], json!(sec.area), "{plain}");
    assert_eq!(plain["section"]["centroid"], json!(sec.centroid), "{plain}");
    assert_eq!(plain["section"]["profile"], serde_json::to_value(profile.filled()).unwrap_or_default(), "{plain}");
    assert_eq!(plain["section"], section);
    let placed = run(
        "frame.profile.insert",
        json!({
            "profile": {"kind": "channel", "height": "60 mm", "width": 45, "web": 5, "flange": 6},
            "at": [100, 50], "anchor": "bottom_left", "angle": 0.5, "fixed": false, "sketch": "Drawing"
        }),
    );
    matches(output_schema_for::<ProfileInsertResult>(), "frame.profile.insert", &placed);
    let by_id = run(
        "frame.profile.insert",
        json!({"profile": {"kind": "round_bar", "diameter": 20}, "sketch": id, "at": {"x": -50, "y": 5}, "anchor": null}),
    );
    matches(output_schema_for::<ProfileInsertResult>(), "frame.profile.insert", &by_id);
    assert_eq!(by_id["created"]["curves"].as_array().map(Vec::len), Some(1), "{by_id}");
    // A misspelt key still runs in Warn, and says so, with a reply that matches.
    let warned = run("frame.profile.insert", json!({"profile": {"kind": "round_bar", "diameter": 5}, "sketch": "Drawing", "ancor": "center"}));
    assert_eq!(warned["param_warnings"], json!(["unknown key `ancor`; did you mean `anchor`?"]), "{warned}");
    let schema = output_schema_for::<ProfileInsertResult>();
    assert!(conforms(schema.as_value(), schema.as_value(), &warned), "{warned}");
}

/// Members in every form, in Warn: each reply matches `FeatureResult` and carries no warning.
#[test]
fn member_replies_match_the_output_schema() {
    let (mut s, lines) = frame_session(ParamCheck::Warn);
    let mut run = |p: Value| s.execute("frame.member", &p).unwrap_or_else(|e| panic!("{p}: {e}"));
    let first = lines.first().cloned().unwrap_or_default();
    let second = lines.get(1).cloned().unwrap_or_default();
    let calls = [
        json!({"sketch": "Frame", "profile": tube()}),
        json!({"sketch": "Frame", "profile": {"kind": "angle", "width": 60, "height": 40, "thickness": "5 mm"}, "lines": [first], "anchor": "bottom_left"}),
        json!({"sketch": "Frame", "profile": tube(), "lines": [first, second], "angle": "90 deg", "mirror": true, "name": "Rails", "body_name": "Rail"}),
        json!({"sketch": "Frame", "profile": tube(), "lines": [first], "angle": 45, "names": {first.clone(): "Chosen"}, "participants": "*"}),
        json!({"sketch": "Frame", "profile": tube(), "lines": null}),
        json!({"sketch": "Frame", "profile_sketch": "Section"}),
        json!({"sketch": "Frame", "profile_sketch": "Section", "profiles": [{"point": [0, 0]}], "exact_regions": true, "lines": [first], "anchor": "center"}),
        json!({"sketch": "Frame", "profile_sketch": "Section", "profiles": "all", "mirror": false, "angle": null, "names": null}),
    ];
    for p in calls {
        let reply = run(p.clone());
        matches(output_schema_for::<FeatureResult>(), "frame.member", &reply);
        assert!(reply["created_bodies"].as_array().is_some_and(|b| !b.is_empty()), "{p}: {reply}");
    }
    // By the id of the sketch.
    let by_id = s_first_sketch_call(&mut s, &first);
    matches(output_schema_for::<FeatureResult>(), "frame.member", &by_id);

    // A misspelt key still runs in Warn, and says so, with a reply that matches.
    let warned =
        s.execute("frame.member", &json!({"sketch": "Frame", "profile": tube(), "lines": [first], "profil": 1})).unwrap_or_else(|e| panic!("{e}"));
    assert_eq!(warned["param_warnings"], json!(["unknown key `profil`; did you mean `profile`?"]), "{warned}");
    let schema = output_schema_for::<FeatureResult>();
    assert!(conforms(schema.as_value(), schema.as_value(), &warned), "{warned}");
}

fn s_first_sketch_call(s: &mut Session, line: &str) -> Value {
    let id = first_sketch(s);
    s.execute("frame.member", &json!({"sketch": id, "profile": tube(), "lines": [line]})).unwrap_or_else(|e| panic!("{e}"))
}