socketioxide_parser_msgpack/
lib.rs

1#![warn(
2    clippy::all,
3    clippy::todo,
4    clippy::empty_enum,
5    clippy::mem_forget,
6    clippy::unused_self,
7    clippy::filter_map_next,
8    clippy::needless_continue,
9    clippy::needless_borrow,
10    clippy::match_wildcard_for_single_variants,
11    clippy::if_let_mutex,
12    clippy::await_holding_lock,
13    clippy::match_on_vec_items,
14    clippy::imprecise_flops,
15    clippy::suboptimal_flops,
16    clippy::lossy_float_literal,
17    clippy::rest_pat_in_fully_bound_structs,
18    clippy::fn_params_excessive_bools,
19    clippy::exit,
20    clippy::inefficient_to_string,
21    clippy::linkedlist,
22    clippy::macro_use_imports,
23    clippy::option_option,
24    clippy::verbose_file_reads,
25    clippy::unnested_or_patterns,
26    rust_2018_idioms,
27    future_incompatible,
28    nonstandard_style,
29    missing_docs
30)]
31
32//! The msgpack parser sub-crate for the socketioxide crate.
33//!
34//! This is a custom parser implementation that can be enable with the `msgpack` feature flag in socketioxide.
35//!
36//! It is used to parse and serialize the msgpack packet format of the socket.io protocol:
37//! ```json
38//! {
39//!   "type": 2,
40//!   "nsp": "/",
41//!   "data": ["event", "foo"],
42//!   "id": 1
43//! }
44//! ```
45//! will be directly converted to the following msgpack binary format:
46//! `84 A4 74 79 70 65 02 A3 6E 73 70 A1 2F A4 64 61 74 61 92 A5 65 76 65 6E 74 A3 66 6F 6F A2 69 64 01`
47
48use bytes::Bytes;
49use de::deserialize_packet;
50use ser::serialize_packet;
51use serde::Deserialize;
52use socketioxide_core::{
53    packet::Packet,
54    parser::{Parse, ParseError, ParserState},
55    Str, Value,
56};
57
58mod de;
59mod ser;
60mod value;
61
62/// The MsgPack parser
63#[derive(Default, Debug, Clone, Copy)]
64pub struct MsgPackParser;
65
66impl Parse for MsgPackParser {
67    type EncodeError = rmp_serde::encode::Error;
68    type DecodeError = rmp_serde::decode::Error;
69
70    fn encode(self, packet: Packet) -> socketioxide_core::Value {
71        let data = serialize_packet(packet);
72        Value::Bytes(data.into())
73    }
74
75    fn decode_str(
76        self,
77        _: &ParserState,
78        _data: Str,
79    ) -> Result<Packet, ParseError<Self::DecodeError>> {
80        Err(ParseError::UnexpectedStringPacket)
81    }
82
83    fn decode_bin(
84        self,
85        _: &ParserState,
86        bin: Bytes,
87    ) -> Result<Packet, ParseError<Self::DecodeError>> {
88        deserialize_packet(bin)
89    }
90
91    fn encode_value<T: ?Sized + serde::Serialize>(
92        self,
93        data: &T,
94        event: Option<&str>,
95    ) -> Result<Value, Self::EncodeError> {
96        value::to_value(data, event)
97    }
98
99    fn decode_value<'de, T: Deserialize<'de>>(
100        self,
101        value: &'de mut Value,
102        with_event: bool,
103    ) -> Result<T, Self::DecodeError> {
104        value::from_value(value, with_event)
105    }
106
107    fn decode_default<'de, T: Deserialize<'de>>(
108        self,
109        value: Option<&'de Value>,
110    ) -> Result<T, Self::DecodeError> {
111        if let Some(value) = value {
112            let value = value.as_bytes().expect("value should be bytes");
113            rmp_serde::from_slice(value)
114        } else {
115            rmp_serde::from_slice(&[0xc0]) // nil value
116        }
117    }
118
119    fn encode_default<T: ?Sized + serde::Serialize>(
120        self,
121        data: &T,
122    ) -> Result<Value, Self::EncodeError> {
123        rmp_serde::to_vec_named(data).map(|b| Value::Bytes(b.into()))
124    }
125
126    fn read_event(self, value: &Value) -> Result<&str, Self::DecodeError> {
127        value::read_event(value)
128    }
129}
130
131/// All the static binary data is generated from this script, using the official socket.io implementation:
132/// https://gist.github.com/Totodore/943fac5107325589bfbfb50f55925698
133#[cfg(test)]
134mod tests {
135    use std::str::FromStr;
136
137    use serde_json::json;
138    use socketioxide_core::{packet::ConnectPacket, Sid};
139
140    use super::*;
141    const BIN: Bytes = Bytes::from_static(&[1, 2, 3, 4]);
142
143    fn decode(value: &'static [u8]) -> Packet {
144        MsgPackParser
145            .decode_bin(&Default::default(), Bytes::from_static(value))
146            .unwrap()
147    }
148    fn encode(packet: Packet) -> Bytes {
149        match MsgPackParser.encode(packet) {
150            Value::Bytes(b) => b,
151            Value::Str(_, _) => panic!("implementation should only return bytes"),
152        }
153    }
154    fn to_event_value(data: &impl serde::Serialize, event: &str) -> Value {
155        MsgPackParser.encode_value(data, Some(event)).unwrap()
156    }
157    fn to_value(data: &impl serde::Serialize) -> Value {
158        MsgPackParser.encode_value(data, None).unwrap()
159    }
160    fn to_connect_value(data: &impl serde::Serialize) -> Value {
161        Value::Bytes(rmp_serde::to_vec_named(data).unwrap().into())
162    }
163
164    #[test]
165    fn packet_encode_connect_root_ns() {
166        const DATA: &[u8] = &[
167            131, 164, 116, 121, 112, 101, 0, 163, 110, 115, 112, 161, 47, 164, 100, 97, 116, 97,
168            129, 163, 115, 105, 100, 176, 110, 119, 122, 51, 67, 56, 117, 55, 113, 121, 115, 118,
169            103, 86, 113, 106,
170        ];
171
172        let sid = Sid::from_str("nwz3C8u7qysvgVqj").unwrap();
173        let sid = to_connect_value(&ConnectPacket { sid });
174        let packet = encode(Packet::connect("/", Some(sid)));
175        assert_eq!(DATA, packet.as_ref());
176    }
177
178    #[test]
179    fn packet_decode_connect_root_ns() {
180        const DATA: &[u8] = &[
181            131, 164, 116, 121, 112, 101, 0, 163, 110, 115, 112, 161, 47, 164, 100, 97, 116, 97,
182            129, 163, 115, 105, 100, 176, 110, 119, 122, 51, 67, 56, 117, 55, 113, 121, 115, 118,
183            103, 86, 113, 106,
184        ];
185        let sid = Sid::from_str("nwz3C8u7qysvgVqj").unwrap();
186        let sid = to_connect_value(&ConnectPacket { sid });
187        let packet = decode(DATA);
188        assert_eq!(packet, Packet::connect("/", Some(sid)));
189    }
190
191    #[test]
192    fn packet_encode_connect_custom_ns() {
193        const DATA: &[u8] = &[
194            131, 164, 116, 121, 112, 101, 0, 163, 110, 115, 112, 169, 47, 97, 100, 109, 105, 110,
195            226, 132, 162, 164, 100, 97, 116, 97, 129, 163, 115, 105, 100, 176, 110, 119, 122, 51,
196            67, 56, 117, 55, 113, 121, 115, 118, 103, 86, 113, 106,
197        ];
198
199        let sid = Sid::from_str("nwz3C8u7qysvgVqj").unwrap();
200        let sid = to_connect_value(&ConnectPacket { sid });
201        let packet = encode(Packet::connect("/admin™", Some(sid)));
202        assert_eq!(DATA, packet.as_ref());
203    }
204
205    #[test]
206    fn packet_decode_connect_custom_ns() {
207        const DATA: &[u8] = &[
208            131, 164, 116, 121, 112, 101, 0, 163, 110, 115, 112, 169, 47, 97, 100, 109, 105, 110,
209            226, 132, 162, 164, 100, 97, 116, 97, 129, 163, 115, 105, 100, 176, 110, 119, 122, 51,
210            67, 56, 117, 55, 113, 121, 115, 118, 103, 86, 113, 106,
211        ];
212
213        let sid = Sid::from_str("nwz3C8u7qysvgVqj").unwrap();
214        let sid = to_connect_value(&ConnectPacket { sid });
215        let packet = decode(DATA);
216        assert_eq!(packet, Packet::connect("/admin™", Some(sid)));
217    }
218
219    #[test]
220    fn packet_encode_disconnect_root_ns() {
221        const DATA: &[u8] = &[130, 164, 116, 121, 112, 101, 1, 163, 110, 115, 112, 161, 47];
222        let packet = encode(Packet::disconnect("/"));
223        assert_eq!(DATA, packet.as_ref());
224    }
225
226    #[test]
227    fn packet_decode_disconnect_root_ns() {
228        const DATA: &[u8] = &[130, 164, 116, 121, 112, 101, 1, 163, 110, 115, 112, 161, 47];
229        let packet = decode(DATA);
230        assert_eq!(packet, Packet::disconnect("/"));
231    }
232
233    #[test]
234    fn packet_encode_disconnect_custom_ns() {
235        const DATA: &[u8] = &[
236            130, 164, 116, 121, 112, 101, 1, 163, 110, 115, 112, 169, 47, 97, 100, 109, 105, 110,
237            226, 132, 162,
238        ];
239        let packet = encode(Packet::disconnect("/admin™"));
240        assert_eq!(DATA, packet.as_ref());
241    }
242
243    #[test]
244    fn packet_decode_disconnect_custom_ns() {
245        const DATA: &[u8] = &[
246            130, 164, 116, 121, 112, 101, 1, 163, 110, 115, 112, 169, 47, 97, 100, 109, 105, 110,
247            226, 132, 162,
248        ];
249        let packet = decode(DATA);
250        assert_eq!(packet, Packet::disconnect("/admin™"));
251    }
252
253    #[test]
254    fn packet_encode_event_root_ns() {
255        const DATA: &[u8] = &[
256            131, 164, 116, 121, 112, 101, 2, 163, 110, 115, 112, 161, 47, 164, 100, 97, 116, 97,
257            146, 165, 101, 118, 101, 110, 116, 129, 164, 100, 97, 116, 97, 168, 118, 97, 108, 117,
258            101, 226, 132, 162,
259        ];
260        let packet = encode(Packet::event(
261            "/",
262            to_event_value(&json!({ "data": "value™" }), "event"),
263        ));
264        assert_eq!(DATA, packet.as_ref());
265    }
266
267    #[test]
268    fn packet_decode_event_root_ns() {
269        const DATA: &[u8] = &[
270            131, 164, 116, 121, 112, 101, 2, 163, 110, 115, 112, 161, 47, 164, 100, 97, 116, 97,
271            146, 165, 101, 118, 101, 110, 116, 129, 164, 100, 97, 116, 97, 168, 118, 97, 108, 117,
272            101, 226, 132, 162,
273        ];
274        let data = to_event_value(&json!({ "data": "value™" }), "event");
275        let packet = decode(DATA);
276        assert_eq!(packet, Packet::event("/", data));
277    }
278    #[test]
279    fn packet_decode_event_root_ns_empty_data() {
280        const DATA: &[u8] = &[
281            131, 164, 116, 121, 112, 101, 2, 163, 110, 115, 112, 161, 47, 164, 100, 97, 116, 97,
282            145, 165, 101, 118, 101, 110, 116,
283        ];
284        let data = to_event_value(&[0; 0], "event");
285        let packet = decode(DATA);
286        assert_eq!(packet, Packet::event("/", data));
287    }
288
289    #[test]
290    fn packet_encode_event_root_ns_with_ack_id() {
291        const DATA: &[u8] = &[
292            132, 164, 116, 121, 112, 101, 2, 163, 110, 115, 112, 161, 47, 164, 100, 97, 116, 97,
293            146, 165, 101, 118, 101, 110, 116, 129, 164, 100, 97, 116, 97, 168, 118, 97, 108, 117,
294            101, 226, 132, 162, 162, 105, 100, 1,
295        ];
296        let data = to_event_value(&json!({ "data": "value™" }), "event");
297        let mut packet = Packet::event("/", data);
298        packet.inner.set_ack_id(1);
299        let packet = encode(packet);
300        assert_eq!(DATA, packet.as_ref());
301    }
302
303    #[test]
304    fn packet_decode_event_root_ns_with_ack_id() {
305        const DATA: &[u8] = &[
306            132, 164, 116, 121, 112, 101, 2, 163, 110, 115, 112, 161, 47, 164, 100, 97, 116, 97,
307            146, 165, 101, 118, 101, 110, 116, 129, 164, 100, 97, 116, 97, 168, 118, 97, 108, 117,
308            101, 226, 132, 162, 162, 105, 100, 1,
309        ];
310        let data = to_event_value(&json!({ "data": "value™" }), "event");
311        let mut packet_comp = Packet::event("/", data);
312        packet_comp.inner.set_ack_id(1);
313        let packet = decode(DATA);
314        assert_eq!(packet, packet_comp);
315    }
316    #[test]
317    fn packet_encode_event_custom_ns() {
318        const DATA: &[u8] = &[
319            131, 164, 116, 121, 112, 101, 2, 163, 110, 115, 112, 169, 47, 97, 100, 109, 105, 110,
320            226, 132, 162, 164, 100, 97, 116, 97, 146, 165, 101, 118, 101, 110, 116, 129, 164, 100,
321            97, 116, 97, 168, 118, 97, 108, 117, 101, 226, 132, 162,
322        ];
323        let data = to_event_value(&json!({"data": "value™"}), "event");
324        let packet = encode(Packet::event("/admin™", data));
325
326        assert_eq!(DATA, packet.as_ref());
327    }
328
329    #[test]
330    fn packet_decode_event_custom_ns() {
331        const DATA: &[u8] = &[
332            131, 164, 116, 121, 112, 101, 2, 163, 110, 115, 112, 169, 47, 97, 100, 109, 105, 110,
333            226, 132, 162, 164, 100, 97, 116, 97, 146, 165, 101, 118, 101, 110, 116, 129, 164, 100,
334            97, 116, 97, 168, 118, 97, 108, 117, 101, 226, 132, 162,
335        ];
336        let data = to_event_value(&json!({"data": "value™"}), "event");
337        let packet = decode(DATA);
338
339        assert_eq!(packet, Packet::event("/admin™", data));
340    }
341    #[test]
342    fn packet_encode_event_custom_ns_with_ack_id() {
343        const DATA: &[u8] = &[
344            132, 164, 116, 121, 112, 101, 2, 163, 110, 115, 112, 169, 47, 97, 100, 109, 105, 110,
345            226, 132, 162, 164, 100, 97, 116, 97, 146, 165, 101, 118, 101, 110, 116, 129, 164, 100,
346            97, 116, 97, 168, 118, 97, 108, 117, 101, 226, 132, 162, 162, 105, 100, 1,
347        ];
348        let data = to_event_value(&json!({"data": "value™"}), "event");
349        let mut packet = Packet::event("/admin™", data);
350        packet.inner.set_ack_id(1);
351        let packet = encode(packet);
352        assert_eq!(DATA, packet.as_ref());
353    }
354
355    #[test]
356    fn packet_decode_event_custom_ns_with_ack_id() {
357        const DATA: &[u8] = &[
358            132, 164, 116, 121, 112, 101, 2, 163, 110, 115, 112, 169, 47, 97, 100, 109, 105, 110,
359            226, 132, 162, 164, 100, 97, 116, 97, 146, 165, 101, 118, 101, 110, 116, 129, 164, 100,
360            97, 116, 97, 168, 118, 97, 108, 117, 101, 226, 132, 162, 162, 105, 100, 1,
361        ];
362        let data = to_event_value(&json!({"data": "value™"}), "event");
363        let mut packet_ref = Packet::event("/admin™", data);
364        packet_ref.inner.set_ack_id(1);
365        let packet = decode(DATA);
366        assert_eq!(packet, packet_ref);
367    }
368
369    #[test]
370    fn packet_encode_event_ack_root_ns() {
371        const DATA: &[u8] = &[
372            132, 164, 116, 121, 112, 101, 3, 163, 110, 115, 112, 161, 47, 164, 100, 97, 116, 97,
373            145, 164, 100, 97, 116, 97, 162, 105, 100, 54,
374        ];
375        let data = to_value(&"data");
376        let packet = encode(Packet::ack("/", data, 54));
377        assert_eq!(DATA, packet.as_ref());
378    }
379
380    #[test]
381    fn packet_decode_event_ack_root_ns() {
382        const DATA: &[u8] = &[
383            132, 164, 116, 121, 112, 101, 3, 163, 110, 115, 112, 161, 47, 164, 100, 97, 116, 97,
384            145, 164, 100, 97, 116, 97, 162, 105, 100, 54,
385        ];
386        let data = to_value(&"data");
387        let packet = decode(DATA);
388        assert_eq!(packet, Packet::ack("/", data, 54));
389    }
390
391    #[test]
392    fn packet_encode_event_ack_custom_ns() {
393        const DATA: &[u8] = &[
394            132, 164, 116, 121, 112, 101, 3, 163, 110, 115, 112, 169, 47, 97, 100, 109, 105, 110,
395            226, 132, 162, 164, 100, 97, 116, 97, 145, 164, 100, 97, 116, 97, 162, 105, 100, 54,
396        ];
397
398        let data = to_value(&"data");
399        let packet = encode(Packet::ack("/admin™", data, 54));
400        assert_eq!(DATA, packet.as_ref());
401    }
402
403    #[test]
404    fn packet_decode_event_ack_custom_ns() {
405        const DATA: &[u8] = &[
406            132, 164, 116, 121, 112, 101, 3, 163, 110, 115, 112, 169, 47, 97, 100, 109, 105, 110,
407            226, 132, 162, 164, 100, 97, 116, 97, 145, 164, 100, 97, 116, 97, 162, 105, 100, 54,
408        ];
409
410        let data = to_value(&["data"]);
411        let packet = decode(DATA);
412        assert_eq!(packet, Packet::ack("/admin™", data, 54));
413    }
414
415    #[test]
416    fn packet_encode_binary_event_root_ns() {
417        const DATA: &[u8] = &[
418            131, 164, 116, 121, 112, 101, 2, 163, 110, 115, 112, 161, 47, 164, 100, 97, 116, 97,
419            147, 165, 101, 118, 101, 110, 116, 129, 164, 100, 97, 116, 97, 168, 118, 97, 108, 117,
420            101, 226, 132, 162, 196, 4, 1, 2, 3, 4,
421        ];
422        let data = to_event_value(&(json!({ "data": "value™" }), BIN), "event");
423        let packet = encode(Packet::event("/", data));
424        assert_eq!(DATA, packet.as_ref());
425    }
426
427    #[test]
428    fn packet_decode_binary_event_root_ns() {
429        const DATA: &[u8] = &[
430            131, 164, 116, 121, 112, 101, 2, 163, 110, 115, 112, 161, 47, 164, 100, 97, 116, 97,
431            147, 165, 101, 118, 101, 110, 116, 129, 164, 100, 97, 116, 97, 168, 118, 97, 108, 117,
432            101, 226, 132, 162, 196, 4, 1, 2, 3, 4,
433        ];
434        let data = to_event_value(&(json!({ "data": "value™" }), BIN), "event");
435        let packet = decode(DATA);
436        assert_eq!(packet, Packet::event("/", data));
437    }
438
439    #[test]
440    fn packet_encode_binary_event_root_ns_with_ack_id() {
441        const DATA: &[u8] = &[
442            132, 164, 116, 121, 112, 101, 2, 163, 110, 115, 112, 161, 47, 164, 100, 97, 116, 97,
443            147, 165, 101, 118, 101, 110, 116, 129, 164, 100, 97, 116, 97, 168, 118, 97, 108, 117,
444            101, 226, 132, 162, 196, 4, 1, 2, 3, 4, 162, 105, 100, 204, 254,
445        ];
446        let data = to_event_value(&(json!({ "data": "value™" }), BIN), "event");
447        let mut packet = Packet::event("/", data);
448        packet.inner.set_ack_id(254);
449        let packet = encode(packet);
450
451        assert_eq!(DATA, packet.as_ref());
452    }
453
454    #[test]
455    fn packet_decode_binary_event_root_ns_with_ack_id() {
456        const DATA: &[u8] = &[
457            132, 164, 116, 121, 112, 101, 2, 163, 110, 115, 112, 161, 47, 164, 100, 97, 116, 97,
458            147, 165, 101, 118, 101, 110, 116, 129, 164, 100, 97, 116, 97, 168, 118, 97, 108, 117,
459            101, 226, 132, 162, 196, 4, 1, 2, 3, 4, 162, 105, 100, 204, 254,
460        ];
461        let data = to_event_value(&(json!({ "data": "value™" }), BIN), "event");
462        let mut packet_ref = Packet::event("/", data);
463        packet_ref.inner.set_ack_id(254);
464        let packet = decode(DATA);
465
466        assert_eq!(packet, packet_ref);
467    }
468
469    #[test]
470    fn packet_encode_binary_event_custom_ns() {
471        const DATA: &[u8] = &[
472            131, 164, 116, 121, 112, 101, 2, 163, 110, 115, 112, 169, 47, 97, 100, 109, 105, 110,
473            226, 132, 162, 164, 100, 97, 116, 97, 147, 165, 101, 118, 101, 110, 116, 129, 164, 100,
474            97, 116, 97, 168, 118, 97, 108, 117, 101, 226, 132, 162, 196, 4, 1, 2, 3, 4,
475        ];
476        let data = to_event_value(&(json!({"data": "value™"}), BIN), "event");
477        let packet = encode(Packet::event("/admin™", data));
478
479        assert_eq!(DATA, packet.as_ref());
480    }
481
482    #[test]
483    fn packet_decode_binary_event_custom_ns() {
484        const DATA: &[u8] = &[
485            131, 164, 116, 121, 112, 101, 2, 163, 110, 115, 112, 169, 47, 97, 100, 109, 105, 110,
486            226, 132, 162, 164, 100, 97, 116, 97, 147, 165, 101, 118, 101, 110, 116, 129, 164, 100,
487            97, 116, 97, 168, 118, 97, 108, 117, 101, 226, 132, 162, 196, 4, 1, 2, 3, 4,
488        ];
489        let data = to_event_value(&(json!({"data": "value™"}), BIN), "event");
490        let packet = decode(DATA);
491
492        assert_eq!(packet, Packet::event("/admin™", data));
493    }
494
495    #[test]
496    fn packet_encode_binary_event_custom_ns_with_ack_id() {
497        const DATA: &[u8] = &[
498            132, 164, 116, 121, 112, 101, 2, 163, 110, 115, 112, 169, 47, 97, 100, 109, 105, 110,
499            226, 132, 162, 164, 100, 97, 116, 97, 147, 165, 101, 118, 101, 110, 116, 129, 164, 100,
500            97, 116, 97, 168, 118, 97, 108, 117, 101, 226, 132, 162, 196, 4, 1, 2, 3, 4, 162, 105,
501            100, 204, 254,
502        ];
503        let data = to_event_value(&(json!({"data": "value™"}), BIN), "event");
504        let mut packet = Packet::event("/admin™", data);
505        packet.inner.set_ack_id(254);
506        let packet = encode(packet);
507        assert_eq!(DATA, packet.as_ref());
508    }
509
510    #[test]
511    fn packet_decode_binary_event_custom_ns_with_ack_id() {
512        const DATA: &[u8] = &[
513            132, 164, 116, 121, 112, 101, 2, 163, 110, 115, 112, 169, 47, 97, 100, 109, 105, 110,
514            226, 132, 162, 164, 100, 97, 116, 97, 147, 165, 101, 118, 101, 110, 116, 129, 164, 100,
515            97, 116, 97, 168, 118, 97, 108, 117, 101, 226, 132, 162, 196, 4, 1, 2, 3, 4, 162, 105,
516            100, 204, 254,
517        ];
518        let data = to_event_value(&(json!({"data": "value™"}), BIN), "event");
519        let mut packet_ref = Packet::event("/admin™", data);
520        packet_ref.inner.set_ack_id(254);
521        let packet = decode(DATA);
522        assert_eq!(packet, packet_ref);
523    }
524
525    #[test]
526    fn packet_encode_binary_ack_root_ns() {
527        const DATA: &[u8] = &[
528            132, 164, 116, 121, 112, 101, 3, 163, 110, 115, 112, 161, 47, 164, 100, 97, 116, 97,
529            146, 129, 164, 100, 97, 116, 97, 168, 118, 97, 108, 117, 101, 226, 132, 162, 196, 4, 1,
530            2, 3, 4, 162, 105, 100, 54,
531        ];
532        let data = to_value(&(json!({ "data": "value™" }), BIN));
533        let packet = encode(Packet::ack("/", data, 54));
534        assert_eq!(DATA, packet.as_ref());
535    }
536
537    #[test]
538    fn packet_decode_binary_ack_root_ns() {
539        const DATA: &[u8] = &[
540            132, 164, 116, 121, 112, 101, 3, 163, 110, 115, 112, 161, 47, 164, 100, 97, 116, 97,
541            146, 129, 164, 100, 97, 116, 97, 168, 118, 97, 108, 117, 101, 226, 132, 162, 196, 4, 1,
542            2, 3, 4, 162, 105, 100, 54,
543        ];
544        let data = to_value(&(json!({ "data": "value™" }), BIN));
545        let packet = decode(DATA);
546        assert_eq!(packet, Packet::ack("/", data, 54));
547    }
548
549    #[test]
550    fn packet_encode_binary_ack_custom_ns() {
551        const DATA: &[u8] = &[
552            132, 164, 116, 121, 112, 101, 3, 163, 110, 115, 112, 169, 47, 97, 100, 109, 105, 110,
553            226, 132, 162, 164, 100, 97, 116, 97, 146, 129, 164, 100, 97, 116, 97, 168, 118, 97,
554            108, 117, 101, 226, 132, 162, 196, 4, 1, 2, 3, 4, 162, 105, 100, 54,
555        ];
556        let data = to_value(&(json!({ "data": "value™" }), BIN));
557        let packet = encode(Packet::ack("/admin™", data, 54));
558
559        assert_eq!(DATA, packet.as_ref());
560    }
561
562    #[test]
563    fn packet_decode_binary_ack_custom_ns() {
564        const DATA: &[u8] = &[
565            132, 164, 116, 121, 112, 101, 3, 163, 110, 115, 112, 169, 47, 97, 100, 109, 105, 110,
566            226, 132, 162, 164, 100, 97, 116, 97, 146, 129, 164, 100, 97, 116, 97, 168, 118, 97,
567            108, 117, 101, 226, 132, 162, 196, 4, 1, 2, 3, 4, 162, 105, 100, 54,
568        ];
569        let data = to_value(&(json!({ "data": "value™" }), BIN));
570        let packet = decode(DATA);
571
572        assert_eq!(packet, Packet::ack("/admin™", data, 54));
573    }
574}
socketioxide_parser_msgpack/lib.rs

socketioxide_parser_msgpack/
lib.rs
