dpp-domain 0.19.0

EU Digital Product Passport domain types, port traits, and per-field disclosure policy
Documentation 
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

//! The `Other` variant constructor for runtime-registered groups.

use super::*;
use serde_json::json;

use crate::product_group::ProductGroup;

/// A non-object payload is refused rather than accepted untagged.
///
/// The hazard is not the round-trip failure, which is merely wrong. It is
/// that `Serialize` only stamps the `product_group` tag onto an object, so an
/// untagged payload slips past `dpp-aas`'s unknown-product group backstop — which
/// keys off exactly that tag — and is filtered by a policy defaulting to
/// `Public`.
#[test]
fn a_non_object_payload_is_refused() {
    for payload in [
        json!([{ "secret": "value" }]),
        json!(42),
        json!("battery"),
        json!(null),
        json!(true),
    ] {
        assert!(
            ProductGroupData::other(payload.clone()).is_none(),
            "a non-object payload must not become ProductGroupData::Other: {payload}"
        );
    }
}

/// An object for an untyped product group is still accepted, tag or not.
#[test]
fn an_object_for_an_unknown_product_group_is_still_accepted() {
    let tagged = ProductGroupData::other(json!({ "productGroup": "quantum-widget", "spinPct": 3 }))
        .expect("an unknown tagged product_group is representable");
    assert_eq!(
        tagged.product_group(),
        ProductGroup::Other("quantum-widget".into())
    );

    let untagged = ProductGroupData::other(json!({ "spinPct": 3 }))
        .expect("an untagged object defaults to other");
    assert_eq!(
        untagged.product_group(),
        ProductGroup::Other("other".into())
    );
}

/// A typed product group's tag is still refused — the pre-existing rule.
#[test]
fn a_typed_product_groups_tag_is_still_refused() {
    assert!(ProductGroupData::other(json!({ "productGroup": "battery" })).is_none());
}

/// Everything this constructor accepts round-trips.
///
/// The property the object guard buys: previously a caller could build a
/// value that serialised to something `Deserialize` then rejected.
#[test]
fn everything_accepted_round_trips() {
    for payload in [
        json!({ "productGroup": "quantum-widget", "spinPct": 3 }),
        json!({ "spinPct": 3 }),
        json!({}),
    ] {
        let Some(built) = ProductGroupData::other(payload.clone()) else {
            continue;
        };
        let wire = serde_json::to_value(&built).expect("serialises");
        assert!(
            wire.get("productGroup")
                .and_then(serde_json::Value::as_str)
                .is_some(),
            "the serialised form must carry a product_group tag: {wire}"
        );
        let back: ProductGroupData = serde_json::from_value(wire).expect("round-trips");
        assert_eq!(back, built);
    }
}