1#![allow(clippy::new_without_default)]
2
3mod add;
4mod delete;
5mod deregister;
6mod error;
7mod get;
8mod getinstances;
9mod getsupporteddm;
10mod getsupportedprotocol;
11mod msg;
12mod notify;
13mod operate;
14mod record;
15mod register;
16mod set;
17
18pub use add::{
19 AddBuilder, AddOperationStatus, AddRespBuilder, AddRespParameterError, CreateObjectBuilder,
20 CreatedObjectResultsBuilder,
21};
22pub use delete::{
23 DeleteBuilder, DeleteRespBuilder, DeleteRespOperationStatus, DeleteRespUnaffectedPathError,
24 DeletedObjectResultsBuilder,
25};
26pub use deregister::{
27 DeregisterBuilder, DeregisterOperationStatus, DeregisterRespBuilder,
28 DeregisteredPathResultBuilder,
29};
30pub use error::ErrorBuilder;
31pub use get::{
32 GetBuilder, GetRespBuilder, ReqPathResultBuilder as GetReqPathResultBuilder,
33 ResolvedPathResultBuilder,
34};
35pub use getinstances::{
36 CurrInstanceBuilder, GetInstancesBuilder, GetInstancesRespBuilder,
37 ReqPathResultBuilder as GetInstancesRespReqPathResultBuilder,
38};
39pub use getsupporteddm::{
40 GSDMCommandResult, GSDMEventResult, GSDMParamResult, GSDMReqObjectResultBuilder,
41 GSDMSupportedObjectResultBuilder, GetSupportedDMBuilder, GetSupportedDMRespBuilder,
42};
43pub use getsupportedprotocol::{GetSupportedProtocolBuilder, GetSupportedProtocolRespBuilder};
44pub use msg::MsgBuilder;
45pub use notify::{NotifyBuilder, NotifyRespBuilder};
46pub use operate::{OperateBuilder, OperateRespBuilder, OperateRespResultBuilder};
47pub use record::{RecordBuilder, SessionContextBuilder};
48pub use register::{
49 RegisterBuilder, RegisterOperationStatus, RegisterRespBuilder, RegisteredPathResultBuilder,
50};
51pub use set::{
52 SetBuilder, SetOperationStatus, SetOperationSuccessBuilder, SetRespBuilder,
53 SetRespParameterError, UpdateObjectBuilder, UpdatedInstanceFailureBuilder,
54 UpdatedObjectResultsBuilder,
55};
56
57#[cfg(test)]
58mod tests {
59 use super::*;
60
61 use std::collections::HashMap;
62
63 use crate::usp::mod_Body::OneOfmsg_body;
64 use crate::usp::mod_Response::OneOfresp_type;
65 use crate::usp::Response;
66 use crate::usp_decoder::try_decode_msg;
67
68 #[test]
69 fn bytes_conversion() {
70 let bytes = b"\
71 \n\x07\n\x03add\x10\x08\x12'\n%*#\x08\x01\x12\x1f\n\x0bDevice.Foo.\x12\x10\n\x05\
72 Param\x12\x05Value\x18\x01\
73 ";
74
75 let msg = try_decode_msg(bytes).unwrap();
76 let bytes2 = msg.to_vec().unwrap();
77 assert_eq!(bytes, &*bytes2);
78 assert_eq!(msg.msg_id(), "add");
79
80 let add_obj = CreateObjectBuilder::new("Device.Foo.".into()).with_param_settings(vec![(
81 "Param".into(),
82 "Value".into(),
83 true,
84 )]);
85 let expected_body = AddBuilder::new()
86 .with_allow_partial(true)
87 .with_create_objs(vec![add_obj])
88 .build()
89 .unwrap();
90 assert_eq!(msg.body.unwrap(), expected_body);
91 }
92
93 #[test]
94 fn new_request_without_context() {
95 let add_obj = CreateObjectBuilder::new("Device.Foo.".into()).with_param_settings(vec![(
96 "Param".into(),
97 "Value".into(),
98 true,
99 )]);
100 let body = AddBuilder::new()
101 .with_allow_partial(true)
102 .with_create_objs(vec![add_obj])
103 .build()
104 .unwrap();
105
106 let msg = MsgBuilder::new()
107 .with_msg_id("add".into())
108 .with_body(body)
109 .build()
110 .unwrap();
111 let bytes = msg.to_vec().expect("serialisation failed");
112
113 let rmsg = try_decode_msg(&bytes).expect("deserialisation failed");
114 assert_eq!(rmsg.msg_id(), "add");
115 assert_eq!(rmsg, msg);
116
117 let bytes2 = rmsg.to_vec().expect("2nd serialisation failed");
118 assert_eq!(bytes, bytes2);
119 }
120
121 #[test]
122 fn roundtrip_delete_request() {
123 let body = DeleteBuilder::new()
124 .with_allow_partial(true)
125 .with_obj_paths(vec!["Device.Foo.2.".into(), "Device.Bar.1.".into()])
126 .build()
127 .unwrap();
128
129 let msg = MsgBuilder::new()
130 .with_msg_id("delete".into())
131 .with_body(body)
132 .build()
133 .unwrap();
134 let bytes = msg.to_vec().expect("serialisation failed");
135
136 let rmsg = try_decode_msg(&bytes).expect("deserialisation failed");
137 assert_eq!(rmsg.msg_id(), "delete");
138 assert_eq!(rmsg, msg);
139
140 let bytes2 = rmsg.to_vec().expect("2nd serialisation failed");
141 assert_eq!(bytes, bytes2);
142 }
143
144 #[test]
145 fn roundtrip_get_request() {
146 let body = GetBuilder::new()
147 .with_max_depth(1)
148 .with_params(vec!["Device.Foo.2.".into(), "Device.Bar.1.".into()])
149 .build()
150 .unwrap();
151
152 let msg = MsgBuilder::new()
153 .with_msg_id("get".into())
154 .with_body(body)
155 .build()
156 .unwrap();
157 let bytes = msg.to_vec().expect("serialisation failed");
158
159 let rmsg = try_decode_msg(&bytes).expect("deserialisation failed");
160 assert_eq!(rmsg.msg_id(), "get");
161 assert_eq!(rmsg, msg);
162
163 let bytes2 = rmsg.to_vec().expect("2nd serialisation failed");
164 assert_eq!(bytes, bytes2);
165 }
166
167 #[test]
168 fn roundtrip_get_instances_request() {
169 let body = GetInstancesBuilder::new()
170 .with_first_level_only(true)
171 .with_obj_paths(vec!["Device.Foo.".into(), "Device.Bar.".into()])
172 .build()
173 .unwrap();
174
175 let msg = MsgBuilder::new()
176 .with_msg_id("get_instances".into())
177 .with_body(body)
178 .build()
179 .unwrap();
180 let bytes = msg.to_vec().expect("serialisation failed");
181
182 let rmsg = try_decode_msg(&bytes).expect("deserialisation failed");
183 assert_eq!(rmsg.msg_id(), "get_instances");
184 assert_eq!(rmsg, msg);
185
186 let bytes2 = rmsg.to_vec().expect("2nd serialisation failed");
187 assert_eq!(bytes, bytes2);
188 }
189
190 #[test]
191 fn roundtrip_get_supported_dm_request() {
192 let body = GetSupportedDMBuilder::new()
193 .with_first_level_only(true)
194 .with_return_events(false)
195 .with_return_commands(false)
196 .with_return_params(false)
197 .with_obj_paths(vec!["Device.Foo.".into(), "Device.Bar.".into()])
198 .build()
199 .unwrap();
200
201 let msg = MsgBuilder::new()
202 .with_msg_id("get_supported_dm".into())
203 .with_body(body)
204 .build()
205 .unwrap();
206 let bytes = msg.to_vec().expect("serialisation failed");
207
208 let rmsg = try_decode_msg(&bytes).expect("deserialisation failed");
209 assert_eq!(rmsg.msg_id(), "get_supported_dm");
210 assert_eq!(rmsg, msg);
211
212 let bytes2 = rmsg.to_vec().expect("2nd serialisation failed");
213 assert_eq!(bytes, bytes2);
214 }
215
216 #[test]
217 fn roundtrip_get_supported_protocol_request() {
218 let body = GetSupportedProtocolBuilder::new("1.1".into())
219 .build()
220 .unwrap();
221
222 let msg = MsgBuilder::new()
223 .with_msg_id("gsp".into())
224 .with_body(body)
225 .build()
226 .unwrap();
227 let bytes = msg.to_vec().expect("serialisation failed");
228
229 let rmsg = try_decode_msg(&bytes).expect("deserialisation failed");
230 assert_eq!(rmsg.msg_id(), "gsp");
231 assert_eq!(rmsg, msg);
232
233 let bytes2 = rmsg.to_vec().expect("2nd serialisation failed");
234 assert_eq!(bytes, bytes2);
235 }
236
237 #[test]
238 fn roundtrip_operate_request() {
239 let body = OperateBuilder::new("Device.Reset()".into())
240 .with_command_key("reset".into())
241 .with_send_resp(true)
242 .with_input_args(vec![("Hard".into(), "Yes, please!".into())])
243 .build()
244 .unwrap();
245
246 let msg = MsgBuilder::new()
247 .with_msg_id("operate".into())
248 .with_body(body)
249 .build()
250 .unwrap();
251 let bytes = msg.to_vec().expect("serialisation failed");
252
253 let rmsg = try_decode_msg(&bytes).expect("deserialisation failed");
254 assert_eq!(rmsg.msg_id(), "operate");
255 assert_eq!(rmsg, msg);
256
257 let bytes2 = rmsg.to_vec().expect("2nd serialisation failed");
258 assert_eq!(bytes, bytes2);
259 }
260
261 #[test]
262 fn roundtrip_set_request() {
263 let updated_objs = UpdateObjectBuilder::new("Device.Foo.1.".into())
264 .with_param_settings(vec![("Param".into(), "Value".into(), true)]);
265 let body = SetBuilder::new()
266 .with_allow_partial(true)
267 .with_update_objs(vec![updated_objs])
268 .build()
269 .unwrap();
270
271 let msg = MsgBuilder::new()
272 .with_msg_id("set".into())
273 .with_body(body)
274 .build()
275 .unwrap();
276 let bytes = msg.to_vec().expect("serialisation failed");
277
278 let rmsg = try_decode_msg(&bytes).expect("deserialisation failed");
279 assert_eq!(rmsg.msg_id(), "set");
280 assert_eq!(rmsg, msg);
281
282 let bytes2 = rmsg.to_vec().expect("2nd serialisation failed");
283 assert_eq!(bytes, bytes2);
284 }
285
286 #[test]
287 fn roundtrip_notify_response() {
288 let body = NotifyRespBuilder::new("notif-foo".into()).build().unwrap();
289 let msg = MsgBuilder::new()
290 .with_msg_id("notif-foo".into())
291 .with_body(body)
292 .build()
293 .unwrap();
294 let bytes = msg.to_vec().expect("serialisation failed");
295
296 let rmsg = try_decode_msg(&bytes).expect("deserialisation failed");
297 assert_eq!(rmsg.msg_id(), "notif-foo");
298 assert_eq!(rmsg, msg);
299
300 let bytes2 = rmsg.to_vec().expect("2nd serialisation failed");
301 assert_eq!(bytes, bytes2);
302 }
303
304 #[test]
305 fn roundtrip_add_response() {
306 let mut keys = HashMap::new();
307 keys.insert("EndpointID".into(), "controller-temp".into());
308 let oper_status = AddOperationStatus::new().set_success(
309 "Device.LocalAgent.Controller.31185.".into(),
310 Vec::new(),
311 keys,
312 );
313 let created_obj_results =
314 CreatedObjectResultsBuilder::new("Device.LocalAgent.Controller.".into(), oper_status);
315 let body = AddRespBuilder::new()
316 .with_created_obj_results(vec![created_obj_results])
317 .build()
318 .unwrap();
319
320 let msg = MsgBuilder::new()
321 .with_msg_id("add-rsp".into())
322 .with_body(body)
323 .build()
324 .unwrap();
325 let bytes = msg.to_vec().expect("serialisation failed");
326
327 let rmsg = try_decode_msg(&bytes).expect("deserialisation failed");
328 assert_eq!(msg.msg_id(), rmsg.msg_id());
329 assert_eq!(msg, rmsg);
330
331 let bytes2 = rmsg.to_vec().expect("2nd serialisation failed");
332 assert_eq!(bytes, bytes2);
333 }
334
335 #[test]
336 fn roundtrip_delete_response() {
337 let deleted_objs = DeletedObjectResultsBuilder::new(
338 "Device.LocalAgent.Controller.[EndpointID==\"controller-temp\"].".into(),
339 )
340 .set_success(
341 vec!["Device.LocalAgent.Controller.31185.".into()],
342 Vec::new(),
343 );
344 let body = DeleteRespBuilder::new()
345 .with_deleted_obj_results(vec![deleted_objs])
346 .build()
347 .unwrap();
348
349 let msg = MsgBuilder::new()
350 .with_msg_id("delete-rsp".into())
351 .with_body(body)
352 .build()
353 .unwrap();
354 let bytes = msg.to_vec().expect("serialisation failed");
355
356 let rmsg = try_decode_msg(&bytes).expect("deserialisation failed");
357 assert_eq!(msg.msg_id(), rmsg.msg_id());
358 assert_eq!(msg, rmsg);
359
360 let bytes2 = rmsg.to_vec().expect("2nd serialisation failed");
361 assert_eq!(bytes, bytes2);
362 }
363
364 #[test]
365 fn roundtrip_get_response() {
366 let resolved = ResolvedPathResultBuilder::new("Device.WiFi.SSID.1.".into())
367 .with_result_params(vec![("Enable".into(), "True".into())]);
368 let path_result = GetReqPathResultBuilder::new(
369 "Device.WiFi.SSID.[SSID==\"Homenetwork\"&&BSSID=00:11:22:33:44:55].".into(),
370 )
371 .with_res_path_results(vec![resolved]);
372 let body = GetRespBuilder::new()
373 .with_req_path_results(vec![path_result])
374 .build()
375 .unwrap();
376
377 let msg = MsgBuilder::new()
378 .with_msg_id("get-rsp".into())
379 .with_body(body)
380 .build()
381 .unwrap();
382 let bytes = msg.to_vec().expect("serialisation failed");
383
384 let rmsg = try_decode_msg(&bytes).expect("deserialisation failed");
385 assert_eq!(msg.msg_id(), rmsg.msg_id());
386 assert_eq!(msg, rmsg);
387
388 let bytes2 = rmsg.to_vec().expect("2nd serialisation failed");
389 assert_eq!(bytes, bytes2);
390 }
391
392 #[test]
393 fn roundtrip_get_instances_response() {
394 let curr_instances = CurrInstanceBuilder::new("Device.WiFi.SSID.1.".into())
395 .with_unique_keys(vec![("Alias".into(), "UserWiFi1".into())]);
396 let req_path_results =
397 GetInstancesRespReqPathResultBuilder::new("Device.WiFi.SSID.".into())
398 .with_curr_insts(vec![curr_instances]);
399 let body = GetInstancesRespBuilder::new()
400 .with_req_path_results(vec![req_path_results])
401 .build()
402 .unwrap();
403
404 let msg = MsgBuilder::new()
405 .with_msg_id("get-instances-rsp".into())
406 .with_body(body)
407 .build()
408 .unwrap();
409 let bytes = msg.to_vec().expect("serialisation failed");
410
411 let rmsg = try_decode_msg(&bytes).expect("deserialisation failed");
412 assert_eq!(msg.msg_id(), rmsg.msg_id());
413 assert_eq!(msg, rmsg);
414
415 let bytes2 = rmsg.to_vec().expect("2nd serialisation failed");
416 assert_eq!(bytes, bytes2);
417 }
418
419 #[test]
420 fn roundtrip_get_supported_dm_response() {
421 let param_result = GSDMParamResult::new("Device.WiFi.Radio.{i}.".into())
422 .set_access_read_only()
423 .set_type_string()
424 .set_value_change_allowed();
425 let cmd_result = GSDMCommandResult::new("NeighboringWiFiDiagnostic()".into())
426 .with_input_arg_names(vec!["a".into()])
427 .with_output_arg_names(vec!["b".into()])
428 .set_sync();
429 let event_result = GSDMEventResult::new("EventA".into()).with_arg_names(vec!["a".into()]);
430
431 let supported_obj_result = GSDMSupportedObjectResultBuilder::new("Device.WiFi.".into())
432 .set_access_read_only()
433 .with_is_multi_instance(false)
434 .with_supported_params(vec![param_result])
435 .with_supported_commands(vec![cmd_result])
436 .with_supported_events(vec![event_result])
437 .with_divergent_paths(vec!["DivergentPath".into()]);
438 let req_obj_results = GSDMReqObjectResultBuilder::new("Device.WiFi.".into())
439 .with_data_model_inst_uri("urn:broadband-forum-org:tr-181-2-12-0".into())
440 .with_supported_objs(vec![supported_obj_result]);
441 let body = GetSupportedDMRespBuilder::new()
442 .with_req_obj_results(vec![req_obj_results])
443 .build()
444 .unwrap();
445
446 let msg = MsgBuilder::new()
447 .with_msg_id("get-supported-dm-rsp".into())
448 .with_body(body)
449 .build()
450 .unwrap();
451 let bytes = msg.to_vec().expect("serialisation failed");
452
453 let rmsg = try_decode_msg(&bytes).expect("deserialisation failed");
454 assert_eq!(msg.msg_id(), rmsg.msg_id());
455 assert_eq!(msg, rmsg);
456
457 let bytes2 = rmsg.to_vec().expect("2nd serialisation failed");
458 assert_eq!(bytes, bytes2);
459 }
460
461 #[test]
462 fn roundtrip_get_supported_protocol_response() {
463 let body = GetSupportedProtocolRespBuilder::new("1.1".into())
464 .build()
465 .unwrap();
466
467 let msg = MsgBuilder::new()
468 .with_msg_id("get-supported-protocol-rsp".into())
469 .with_body(body)
470 .build()
471 .unwrap();
472 let bytes = msg.to_vec().expect("serialisation failed");
473
474 let rmsg = try_decode_msg(&bytes).expect("deserialisation failed");
475 assert_eq!(msg.msg_id(), rmsg.msg_id());
476 assert_eq!(msg, rmsg);
477
478 let bytes2 = rmsg.to_vec().expect("2nd serialisation failed");
479 assert_eq!(bytes, bytes2);
480 }
481
482 #[test]
483 fn roundtrip_operate_response() {
484 let oper_sync = OperateRespResultBuilder::new(
485 "Device.LocalAgent.Controller.1.SendOnBoardRequest()".into(),
486 )
487 .set_output_args(vec![("a".into(), "b".into())]);
488 let oper_async =
489 OperateRespResultBuilder::new("Device.LocalAgent.Controller.1.Send()".into())
490 .set_path("Path".into());
491 let oper_error =
492 OperateRespResultBuilder::new("Device.LocalAgent.Controller.1.Wake()".into())
493 .set_failure(7000, Some("SomeError".into()));
494 let body = OperateRespBuilder::new()
495 .with_operation_results(vec![oper_sync, oper_async, oper_error])
496 .build()
497 .unwrap();
498
499 let msg = MsgBuilder::new()
500 .with_msg_id("operate-rsp".into())
501 .with_body(body)
502 .build()
503 .unwrap();
504 let bytes = msg.to_vec().expect("serialisation failed");
505
506 let rmsg = try_decode_msg(&bytes).expect("deserialisation failed");
507 assert_eq!(msg.msg_id(), rmsg.msg_id());
508 assert_eq!(msg, rmsg);
509
510 let bytes2 = rmsg.to_vec().expect("2nd serialisation failed");
511 assert_eq!(bytes, bytes2);
512 }
513
514 #[test]
515 fn roundtrip_set_response() {
516 let mut params = HashMap::new();
517 params.insert("FriendlyName".into(), "MyDevicesFriendlyName".into());
518 let success = SetOperationSuccessBuilder::new("Device.DeviceInfo.".into())
519 .with_updated_params(params);
520
521 let oper_status = SetOperationStatus::new().set_success(vec![success]);
523 let updated_obj_results =
524 UpdatedObjectResultsBuilder::new("Device.DeviceInfo.".into(), oper_status);
525 let body = SetRespBuilder::new()
526 .with_updated_obj_results(vec![updated_obj_results])
527 .build()
528 .unwrap();
529
530 let msg = MsgBuilder::new()
531 .with_msg_id("set-rsp".into())
532 .with_body(body)
533 .build()
534 .unwrap();
535 let bytes = msg.to_vec().expect("serialisation failed");
536
537 let rmsg = try_decode_msg(&bytes).expect("deserialisation failed");
538 assert_eq!(msg.msg_id(), rmsg.msg_id());
539 assert_eq!(msg, rmsg);
540
541 let bytes2 = rmsg.to_vec().expect("2nd serialisation failed");
542 assert_eq!(bytes, bytes2);
543 }
544
545 #[test]
546 fn get_response_fail() {
547 let req_path_res = GetReqPathResultBuilder::new("Device.DeviceInfo.SerialNumber.".into())
548 .set_err(7026, Some("Invalid path".into()));
549 let body = GetRespBuilder::new()
550 .with_req_path_results(vec![req_path_res])
551 .build()
552 .unwrap();
553
554 let msg = MsgBuilder::new()
555 .with_msg_id("o0qZQ4NaYPjRJyckiYlj8w==".into())
556 .with_body(body)
557 .build()
558 .unwrap();
559 let data = b"\
560 \x0a\x1c\x0a\x18o0qZQ4NaYPjRJyckiYlj8w==\x10\x02\x12\x3a\x128\x0a6\x0a4\x0a\x1f\
561 Device.DeviceInfo.SerialNumber.\x15r\x1b\x00\x00\x1a\x0cInvalid path\
562 ";
563
564 let rmsg = try_decode_msg(data).expect("deserialisation failed");
565 assert_eq!(msg, rmsg);
566 }
567
568 #[test]
569 fn get_response_success() {
570 let resolved = ResolvedPathResultBuilder::new("Device.DeviceInfo.".into())
571 .with_result_params(vec![("SerialNumber".into(), "000000000000".into())]);
572 let req_path_res = GetReqPathResultBuilder::new("Device.DeviceInfo.SerialNumber".into())
573 .with_res_path_results(vec![resolved]);
574 let body = GetRespBuilder::new()
575 .with_req_path_results(vec![req_path_res])
576 .build()
577 .unwrap();
578
579 let msg = MsgBuilder::new()
580 .with_msg_id("A204VyO0B0mNj1DKnIMGlA==".into())
581 .with_body(body)
582 .build()
583 .unwrap();
584 let data = b"\
585 \x0a\x1c\x0a\x18A204VyO0B0mNj1DKnIMGlA==\x10\x02\x12Z\x12X\x0aV\x0aT\x0a\x1e\
586 Device.DeviceInfo.SerialNumber\x222\x0a\x12Device.DeviceInfo.\x12\x1c\x0a\x0c\
587 SerialNumber\x12\x0c000000000000\
588 ";
589
590 let rmsg = try_decode_msg(data).expect("deserialisation failed");
591 assert_eq!(msg, rmsg);
592 }
593
594 #[test]
595 fn get_instances_response_success() {
596 let data = b"\
597 \x0a\x1c\x0a\x18DupoyC6r4HNdfwJtWduvWA==\x10\x0f\x12\xbd\x05\x12\xba\x05\x1a\xb7\x05\
598 \x0a\xb4\x05\x0a\x1dDevice.LocalAgent.Controller.\x22T\x0a\x1f\
599 Device.LocalAgent.Controller.1.\x12\x0f\x0a\x05Alias\x12\x06cpe-01\x12 \x0a\x0a\
600 EndpointID\x12\x12proto\x3a\x3acontroller2\x22T\x0a\x1fDevice.LocalAgent.Controller.2.\
601 \x12\x0f\x0a\x05Alias\x12\x06cpe-02\x12 \x0a\x0aEndpointID\x12\x12proto\x3a\x3a\
602 controller3\x22X\x0a\x1fDevice.LocalAgent.Controller.3.\x12\x0f\x0a\x05Alias\x12\x06\
603 cpe-03\x12\x24\x0a\x0aEndpointID\x12\x16proto\x3a\x3acontroller-mqtt\x22N\x0a\x1f\
604 Device.LocalAgent.Controller.4.\x12\x0f\x0a\x05Alias\x12\x06cpe-04\x12\x1a\x0a\x0a\
605 EndpointID\x12\x0cproto\x3a\x3aaxess\x22O\x0a\x25Device.LocalAgent.Controller.1.MTP.1.\
606 \x12\x0f\x0a\x05Alias\x12\x06cpe-01\x12\x15\x0a\x08Protocol\x12\x09WebSocket\x22O\x0a\
607 \x25Device.LocalAgent.Controller.2.MTP.1.\x12\x0f\x0a\x05Alias\x12\x06cpe-01\
608 \x12\x15\x0a\x08Protocol\x12\x09WebSocket\x22J\x0a\x25Device.LocalAgent.Controller.3.\
609 MTP.1.\x12\x0f\x0a\x05Alias\x12\x06cpe-01\x12\x10\x0a\x08Protocol\x12\x04MQTT\x22O\
610 \x0a\x25Device.LocalAgent.Controller.4.MTP.1.\x12\x0f\x0a\x05Alias\x12\x06cpe-01\
611 \x12\x15\x0a\x08Protocol\x12\x09WebSocket\
612 ";
613
614 let msg = try_decode_msg(data).expect("deserialisation failed");
615 assert!(matches!(
616 msg.body.unwrap().msg_body,
617 OneOfmsg_body::response(Response {
618 resp_type: OneOfresp_type::get_instances_resp(_)
619 })
620 ));
621 }
622
623 #[test]
624 fn add_response_success() {
625 let data = b"\
626 \x0a\x1c\x0a\x18icfeSgQ89emT4XgldRvLjw==\x10\x09\x12\x9d\x01\x12\x9a\x01*\x97\x01\x0a\
627 \x94\x01\x0a\x1fDevice.LocalAgent.Subscription.\x12q\x12o\x0a!Device.LocalAgent.\
628 Subscription.7.\x1a\x0c\x0a\x02ID\x12\x06random\x1a\x0f\x0a\x05Alias\x12\x06cpe-07\x1a\
629 \x2b\x0a\x09Recipient\x12\x1eDevice.LocalAgent.Controller.1\
630 ";
631
632 let msg = try_decode_msg(data).expect("deserialisation failed");
633 assert!(matches!(
634 msg.body.unwrap().msg_body,
635 OneOfmsg_body::response(Response {
636 resp_type: OneOfresp_type::add_resp(_)
637 }),
638 ));
639 }
640
641 #[test]
642 fn delete_response_success() {
643 let data = b"\
644 \x0a\x1c\x0a\x18ZkNuikL7esrADyE4qDDAYw==\x10\x0b\x12P\x12N2L\x0aJ\x0a!Device\
645 .LocalAgent.Subscription.6.\x12\x25\x12\x23\x0a!Device.LocalAgent.Subscription.6.\
646 ";
647
648 let msg = try_decode_msg(data).expect("deserialisation failed");
649 assert!(matches!(
650 msg.body.unwrap().msg_body,
651 OneOfmsg_body::response(Response {
652 resp_type: OneOfresp_type::delete_resp(_)
653 }),
654 ));
655 }
656
657 #[test]
658 fn delete_response_failure() {
659 let data = b"\
660 \x0a\x1c\x0a\x18FwSOgGIWdYgEtJJ\x2bIPi9wQ==\x10\x0b\x12e\x12c2a\x0a_\x0a!Device\
661 .LocalAgent.Subscription.6.\x12\x3a\x128\x126\x0a!Device.LocalAgent.Subscription.6.\
662 \x15r\x1b\x00\x00\x1a\x0cInvalid path\
663 ";
664
665 let msg = try_decode_msg(data).expect("deserialisation failed");
666 assert!(matches!(
667 msg.body.unwrap().msg_body,
668 OneOfmsg_body::response(Response {
669 resp_type: OneOfresp_type::delete_resp(_)
670 }),
671 ));
672 }
673
674 #[test]
675 fn gsp_response() {
676 let body = GetSupportedProtocolRespBuilder::new("1.1".into())
677 .build()
678 .unwrap();
679 let msg = MsgBuilder::new()
680 .with_msg_id("CXOue8V6Pg/hYC4bKfO8rw==".into())
681 .with_body(body)
682 .build()
683 .unwrap();
684
685 let data = b"\n\x1c\n\x18CXOue8V6Pg/hYC4bKfO8rw==\x10\x12\x12\t\x12\x07J\x05\n\x031.1";
686 let rmsg = try_decode_msg(data).expect("deserialisation failed");
687
688 assert_eq!(msg, rmsg);
689 }
690
691 #[test]
692 fn gsdm_response() {
693 let data = b"\
694 \x0a\x1c\x0a\x18Kvcqv3OyewkSHpzRL9LD5Q==\x10\x0d\x12\xac\x02\x12\xa9\x02\x12\xa6\x02\
695 \x0a\xa3\x02\x0a\x12Device.DeviceInfo.*\x8c\x02\x0a\x12Device.DeviceInfo.2\x0e\x0a\x0c\
696 Manufacturer2\x11\x0a\x0fManufacturerOUI2\x0b\x0a\x09ModelName2\x0d\x0a\x0b\
697 Description2\x0e\x0a\x0cProductClass2\x0e\x0a\x0cSerialNumber2\x11\x0a\x0f\
698 HardwareVersion2\x11\x0a\x0fSoftwareVersion2\x14\x0a\x10ProvisioningCode\x10\x012\x08\
699 \x0a\x06UpTime2\x0e\x0a\x0cFirstUseDate2!\x0a\x1fVendorConfigFileNumberOfEntries2\x1e\
700 \x0a\x1cVendorLogFileNumberOfEntries\
701 ";
702 let msg = try_decode_msg(data).expect("deserialisation failed");
703
704 assert!(matches!(
705 msg.body.unwrap().msg_body,
706 OneOfmsg_body::response(Response {
707 resp_type: OneOfresp_type::get_supported_dm_resp(_)
708 }),
709 ));
710 }
711
712 #[test]
713 fn operate_response() {
714 let data = b"\
715 \x0a\x1c\x0a\x18MuyKWcNrbc2lFvQJO0peHA==\x10\x07\x12\x19\x12\x17\x3a\x15\x0a\x13\x0a\
716 \x0fDevice.Reboot()\x1a\x00\
717 ";
718 let msg = try_decode_msg(data).expect("deserialisation failed");
719
720 assert!(matches!(
721 msg.body.unwrap().msg_body,
722 OneOfmsg_body::response(Response {
723 resp_type: OneOfresp_type::operate_resp(_)
724 }),
725 ));
726 }
727
728 #[test]
729 fn set_response() {
730 let data = b"\
731 \x0a\x1c\x0a\x18OCmrwerp73bqFKd2ocHhBw==\x10\x05\x12Z\x12X\x22V\x0aT\x0a\x18\
732 Device.ManagementServer.\x128\x126\x0a4\x0a\x18Device.ManagementServer.\x1a\x18\x0a\
733 \x13AutoCreateInstances\x12\x011\
734 ";
735 let msg = try_decode_msg(data).expect("deserialisation failed");
736
737 assert!(matches!(
738 msg.body.unwrap().msg_body,
739 OneOfmsg_body::response(Response {
740 resp_type: OneOfresp_type::set_resp(_)
741 }),
742 ));
743 }
744}