cadmpeg-ir 0.6.1

CAD data model, validation, diffing, and codec API for cadmpeg.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

// SPDX-License-Identifier: Apache-2.0
//! The profile member nests its curve under `profile`, so the curve's own
//! deny is reached and the member refuses unknown keys on both levels.

use crate::geometry::{LoftMemberForm, LoftPathCurve, LoftProfileMember, LoftSubdata};
use crate::ids::CurveId;

fn member() -> LoftProfileMember {
    LoftProfileMember {
        profile: LoftPathCurve {
            id: CurveId::mint("test:model:curve#loft").expect("valid identity"),
            endpoints: Some([Some(0.0), Some(1.0)]),
        },
        form: LoftMemberForm::PcurvePair {
            pcurve: None,
            secondary_pcurve: None,
            asm_extension: None,
            subdata: LoftSubdata::type_211([1, 0], [0.0, 1.0]),
            direction: None,
        },
    }
}

#[test]
fn a_loft_profile_member_nests_its_curve_and_refuses_unknown_keys() {
    let value = member();
    let wire = serde_json::to_value(&value).expect("serializes");
    assert_eq!(wire["profile"]["curve"], "test:model:curve#loft");
    assert_eq!(wire["profile"]["endpoints"], serde_json::json!([0.0, 1.0]));
    assert!(wire.get("curve").is_none());
    assert_eq!(
        serde_json::from_value::<LoftProfileMember>(wire.clone()).expect("round trip"),
        value
    );

    let mut beside = wire.clone();
    beside["zz_bogus"] = serde_json::json!(1);
    let error = serde_json::from_value::<LoftProfileMember>(beside)
        .unwrap_err()
        .to_string();
    assert_eq!(
        error,
        "unknown field `zz_bogus`, expected `profile` or `form`"
    );

    let mut inside = wire;
    inside["profile"]["zz_bogus"] = serde_json::json!(1);
    let error = serde_json::from_value::<LoftProfileMember>(inside)
        .unwrap_err()
        .to_string();
    assert_eq!(
        error,
        "unknown field `zz_bogus`, expected `curve` or `endpoints`"
    );
}

// The classic profile data carries every field it needs and no field it
// cannot use, so the revision-gated `support_bounds` and the type-zero
// `secondary_pcurve` are unknown keys rather than values a reader refuses.
#[test]
fn classic_loft_profile_data_states_only_its_own_fields() {
    use crate::geometry::ClassicLoftProfileData;

    let wire = serde_json::json!({
        "surface": "test:model:surface#loft",
        "first_flag": true,
        "asm_extension": 3,
        "subdata": {
            "form": "type211",
            "dimensions": [1, 0],
            "row": [0.0, 1.0]
        }
    });
    let data: ClassicLoftProfileData =
        serde_json::from_value(wire.clone()).expect("classic loft data reads");
    assert!(data.pcurve.is_none());
    assert!(data.direction.is_none());
    assert_eq!(serde_json::to_value(&data).expect("serializes"), wire);

    // The classic form declares exactly these six keys, in this order
    // (`ClassicLoftProfileData` in `crates/cadmpeg-ir/src/geometry.rs`), and
    // `deny_unknown_fields` names them all in the refusal.
    let declared = "`surface`, `pcurve`, `first_flag`, `asm_extension`, `subdata`, `direction`";
    for (key, value) in [
        ("support_bounds", serde_json::json!([null, null, null, 2.0])),
        ("secondary_pcurve", serde_json::json!(null)),
        ("zz_bogus", serde_json::json!(true)),
    ] {
        let mut orphan = wire.clone();
        orphan[key] = value;
        let error = serde_json::from_value::<ClassicLoftProfileData>(orphan)
            .expect_err("the classic form states no such field")
            .to_string();
        assert_eq!(
            error,
            format!("unknown field `{key}`, expected one of {declared}"),
            "{key}"
        );
    }

    for required in ["surface", "first_flag", "asm_extension", "subdata"] {
        let mut missing = wire.clone();
        missing
            .as_object_mut()
            .expect("an object")
            .remove(required)
            .expect("the field is present");
        let error = serde_json::from_value::<ClassicLoftProfileData>(missing)
            .expect_err("the classic form requires the field")
            .to_string();
        assert_eq!(error, format!("missing field `{required}`"), "{required}");
    }
}