ocpp-types 0.3.0

Strongly typed OCPP 1.6J, 2.0.1, and 2.1 message types for Rust. no_std, no alloc, embedded-friendly.
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
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
114
115
116
117
118

//! Regression coverage for schema properties with no declared type -- the
//! `data` field on 2.0.1/2.1's `DataTransfer`, which the spec deliberately
//! leaves "open to implementation" (see `ocpp-codegen`'s `RustType::Any`).
//! These used to be generated as `Option<()>`, which is structurally
//! incapable of carrying the vendor payload the message exists to transport;
//! they're now a caller-chosen type parameter, so the real check is that a
//! concrete payload actually round-trips on the wire.

#[cfg(all(test, feature = "serde"))]
mod untyped_data {
    use crate::Action;

    #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
    struct VendorPayload {
        #[serde(rename = "sessionId")]
        session_id: heapless::String<16>,
        counter: i64,
    }

    fn payload() -> VendorPayload {
        VendorPayload {
            session_id: heapless::String::try_from("S-42").unwrap(),
            counter: 7,
        }
    }

    #[test]
    fn v201_request_round_trips_a_caller_chosen_payload() {
        use crate::v201::DataTransferRequest;

        let request: DataTransferRequest<VendorPayload> = DataTransferRequest {
            custom_data: None,
            data: Some(payload()),
            message_id: None,
            vendor_id: heapless::String::try_from("com.example").unwrap(),
        };

        let mut buf = [0u8; 256];
        let json = request.to_json_str(&mut buf).unwrap();
        assert_eq!(
            json,
            r#"{"data":{"sessionId":"S-42","counter":7},"vendorId":"com.example"}"#
        );

        let parsed = DataTransferRequest::<VendorPayload>::from_json_str(json).unwrap();
        assert_eq!(parsed, request);
    }

    #[test]
    fn v201_response_round_trips_a_caller_chosen_payload() {
        use crate::v201::common::DataTransferStatusEnum;
        use crate::v201::DataTransferResponse;

        let response: DataTransferResponse<VendorPayload> = DataTransferResponse {
            custom_data: None,
            data: Some(payload()),
            status: DataTransferStatusEnum::Accepted,
            status_info: None,
        };

        let mut buf = [0u8; 256];
        let json = response.to_json_str(&mut buf).unwrap();
        assert_eq!(
            json,
            r#"{"data":{"sessionId":"S-42","counter":7},"status":"Accepted"}"#
        );

        let parsed = DataTransferResponse::<VendorPayload>::from_json_str(json).unwrap();
        assert_eq!(parsed, response);
    }

    #[test]
    fn v21_request_round_trips_a_caller_chosen_payload() {
        use crate::v21::DataTransferRequest;

        let request: DataTransferRequest<VendorPayload> = DataTransferRequest {
            custom_data: None,
            data: Some(payload()),
            message_id: None,
            vendor_id: heapless::String::try_from("com.example").unwrap(),
        };

        let mut buf = [0u8; 256];
        let json = request.to_json_str(&mut buf).unwrap();
        let parsed = DataTransferRequest::<VendorPayload>::from_json_str(json).unwrap();

        assert_eq!(parsed, request);
    }

    /// A payload type isn't required: code that never sends `data` keeps
    /// working with the default `()`, exactly as it did before the field
    /// became generic.
    #[test]
    fn the_default_payload_type_still_omits_the_field_entirely() {
        use crate::v201::DataTransferRequest;

        let request: DataTransferRequest = DataTransferRequest {
            custom_data: None,
            data: None,
            message_id: None,
            vendor_id: heapless::String::try_from("com.example").unwrap(),
        };

        let mut buf = [0u8; 128];
        let json = request.to_json_str(&mut buf).unwrap();
        assert_eq!(json, r#"{"vendorId":"com.example"}"#);
    }

    /// The action name is unchanged by the payload type -- the `Action` impl
    /// is generic over it.
    #[test]
    fn action_name_is_available_for_any_payload_type() {
        use crate::v201::DataTransferRequest;

        assert_eq!(DataTransferRequest::<VendorPayload>::ACTION, "DataTransfer");
        assert_eq!(DataTransferRequest::<()>::ACTION, "DataTransfer");
    }
}