1use crate::{
2 types::{
3 serde::{
4 date_time::BoltDateTimeVisitor,
5 element::ElementDataDeserializer,
6 node::BoltNodeVisitor,
7 path::BoltPathVisitor,
8 point::{self, BoltPointDeserializer, BoltPointVisitor},
9 rel::BoltRelationVisitor,
10 urel::BoltUnboundedRelationVisitor,
11 BoltKind,
12 },
13 BoltBoolean, BoltBytes, BoltDate, BoltDateTime, BoltDateTimeZoneId, BoltFloat, BoltInteger,
14 BoltList, BoltLocalDateTime, BoltLocalTime, BoltMap, BoltNull, BoltString, BoltTime,
15 BoltType,
16 },
17 DeError,
18};
19
20use std::{fmt, result::Result};
21
22use bytes::Bytes;
23use serde::{
24 de::{
25 value::{
26 BorrowedBytesDeserializer, BorrowedStrDeserializer, MapDeserializer, SeqDeserializer,
27 },
28 DeserializeSeed, Deserializer, EnumAccess, Error, Expected, IntoDeserializer,
29 Unexpected as Unexp, VariantAccess, Visitor,
30 },
31 Deserialize,
32};
33
34impl<'de> Deserialize<'de> for BoltType {
35 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
36 where
37 D: Deserializer<'de>,
38 {
39 deserializer.deserialize_enum(std::any::type_name::<BoltType>(), &[], BoltTypeVisitor)
40 }
41}
42
43impl BoltType {
44 pub(crate) fn to<'this, T>(&'this self) -> Result<T, DeError>
45 where
46 T: Deserialize<'this>,
47 {
48 T::deserialize(self.into_deserializer())
49 }
50}
51
52impl BoltMap {
53 pub(crate) fn to<'this, T>(&'this self) -> Result<T, DeError>
54 where
55 T: Deserialize<'this>,
56 {
57 T::deserialize(MapDeserializer::new(self.value.iter()))
58 }
59}
60
61struct BoltTypeVisitor;
62
63impl<'de> Visitor<'de> for BoltTypeVisitor {
64 type Value = BoltType;
65
66 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
67 formatter.write_str("a valid bolt type")
68 }
69
70 fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
71 where
72 E: Error,
73 {
74 Ok(BoltType::Boolean(BoltBoolean::new(v)))
75 }
76
77 fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
78 where
79 E: Error,
80 {
81 Ok(BoltType::Integer(BoltInteger::new(v)))
82 }
83
84 fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
85 where
86 E: Error,
87 {
88 match i64::try_from(v) {
89 Ok(v) => self.visit_i64(v),
90 Err(_) => Err(E::custom(format!("i128 out of range: {}", v))),
91 }
92 }
93
94 fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
95 where
96 E: Error,
97 {
98 match i64::try_from(v) {
99 Ok(v) => self.visit_i64(v),
100 Err(_) => Err(E::custom(format!("u64 out of range: {}", v))),
101 }
102 }
103
104 fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
105 where
106 E: Error,
107 {
108 match i64::try_from(v) {
109 Ok(v) => self.visit_i64(v),
110 Err(_) => Err(E::custom(format!("u128 out of range: {}", v))),
111 }
112 }
113
114 fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
115 where
116 E: Error,
117 {
118 Ok(BoltType::Float(BoltFloat::new(v)))
119 }
120
121 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
122 where
123 E: Error,
124 {
125 Ok(BoltType::String(BoltString::new(v)))
126 }
127
128 fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
129 where
130 E: Error,
131 {
132 Ok(BoltType::Bytes(BoltBytes::new(Bytes::copy_from_slice(v))))
133 }
134
135 fn visit_none<E>(self) -> Result<Self::Value, E>
136 where
137 E: Error,
138 {
139 Ok(BoltType::Null(BoltNull))
140 }
141
142 fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
143 where
144 D: Deserializer<'de>,
145 {
146 ::serde::de::Deserialize::deserialize(deserializer)
147 }
148
149 fn visit_unit<E>(self) -> Result<Self::Value, E>
150 where
151 E: Error,
152 {
153 Ok(BoltType::Null(BoltNull))
154 }
155
156 fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
157 where
158 D: Deserializer<'de>,
159 {
160 self.visit_some(deserializer)
161 }
162
163 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
164 where
165 A: ::serde::de::SeqAccess<'de>,
166 {
167 let mut items = match seq.size_hint() {
168 Some(s) => BoltList::with_capacity(s),
169 None => BoltList::new(),
170 };
171
172 while let Some(next) = seq.next_element()? {
173 items.push(next);
174 }
175
176 Ok(BoltType::List(items))
177 }
178
179 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
180 where
181 A: ::serde::de::MapAccess<'de>,
182 {
183 let mut items = match map.size_hint() {
184 Some(s) => BoltMap::with_capacity(s),
185 None => BoltMap::new(),
186 };
187
188 while let Some((key, value)) = map.next_entry()? {
189 items.put(key, value);
190 }
191
192 Ok(BoltType::Map(items))
193 }
194
195 fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
196 where
197 E: Error,
198 {
199 Ok(BoltType::String(BoltString { value: v }))
200 }
201
202 fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
203 where
204 E: Error,
205 {
206 Ok(BoltType::Bytes(BoltBytes {
207 value: Bytes::from(v),
208 }))
209 }
210
211 fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
212 where
213 A: serde::de::EnumAccess<'de>,
214 {
215 let (kind, variant): (BoltKind, _) = data.variant()?;
216 match kind {
217 BoltKind::Null => variant.tuple_variant(1, self),
218 BoltKind::String => variant.tuple_variant(1, self),
219 BoltKind::Boolean => variant.tuple_variant(1, self),
220 BoltKind::Map => variant.tuple_variant(1, self),
221 BoltKind::Integer => variant.tuple_variant(1, self),
222 BoltKind::Float => variant.tuple_variant(1, self),
223 BoltKind::List => variant.tuple_variant(1, self),
224 BoltKind::Node => variant
225 .tuple_variant(1, BoltNodeVisitor)
226 .map(BoltType::Node),
227 BoltKind::Relation => variant
228 .tuple_variant(1, BoltRelationVisitor)
229 .map(BoltType::Relation),
230 BoltKind::UnboundedRelation => variant
231 .tuple_variant(1, BoltUnboundedRelationVisitor)
232 .map(BoltType::UnboundedRelation),
233 BoltKind::Point2D => variant
234 .struct_variant(
235 &point::Field::NAMES[..3],
236 BoltPointVisitor::_2d::<A::Error>(),
237 )
238 .map(BoltType::Point2D),
239 BoltKind::Point3D => variant
240 .struct_variant(point::Field::NAMES, BoltPointVisitor::_3d::<A::Error>())
241 .map(BoltType::Point3D),
242 BoltKind::Bytes => variant.tuple_variant(1, self),
243 BoltKind::Path => variant
244 .tuple_variant(1, BoltPathVisitor)
245 .map(BoltType::Path),
246 BoltKind::Duration => variant.tuple_variant(1, self),
247 BoltKind::Date => variant
248 .tuple_variant(1, BoltDateTimeVisitor::<BoltDate>::new())
249 .map(BoltType::Date),
250 BoltKind::Time => variant
251 .tuple_variant(1, BoltDateTimeVisitor::<BoltTime>::new())
252 .map(BoltType::Time),
253 BoltKind::LocalTime => variant
254 .tuple_variant(1, BoltDateTimeVisitor::<BoltLocalTime>::new())
255 .map(BoltType::LocalTime),
256 BoltKind::DateTime => variant
257 .tuple_variant(1, BoltDateTimeVisitor::<BoltDateTime>::new())
258 .map(BoltType::DateTime),
259 BoltKind::LocalDateTime => variant
260 .tuple_variant(1, BoltDateTimeVisitor::<BoltLocalDateTime>::new())
261 .map(BoltType::LocalDateTime),
262 BoltKind::DateTimeZoneId => variant
263 .tuple_variant(1, BoltDateTimeVisitor::<BoltDateTimeZoneId>::new())
264 .map(BoltType::DateTimeZoneId),
265 }
266 }
267}
268
269pub struct BoltTypeDeserializer<'de> {
270 value: &'de BoltType,
271}
272
273impl<'de> Deserializer<'de> for BoltTypeDeserializer<'de> {
274 type Error = DeError;
275
276 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
277 where
278 V: Visitor<'de>,
279 {
280 match self.value {
281 BoltType::List(v) => visitor.visit_seq(SeqDeserializer::new(v.value.iter())),
282 BoltType::Bytes(v) => visitor.visit_seq(SeqDeserializer::new(v.value.iter().copied())),
283 BoltType::Point2D(p) => p.into_deserializer().deserialize_seq(visitor),
284 BoltType::Point3D(p) => p.into_deserializer().deserialize_seq(visitor),
285 _ => self.unexpected(visitor),
286 }
287 }
288
289 fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
290 where
291 V: Visitor<'de>,
292 {
293 match self.value {
294 BoltType::Map(v) => visitor.visit_map(MapDeserializer::new(v.value.iter())),
295 BoltType::Node(v) => v.into_deserializer().deserialize_map(visitor),
296 BoltType::Relation(v) => v.into_deserializer().deserialize_map(visitor),
297 BoltType::UnboundedRelation(v) => v.into_deserializer().deserialize_map(visitor),
298 BoltType::Path(p) => p.into_deserializer().deserialize_map(visitor),
299 BoltType::Point2D(p) => p.into_deserializer().deserialize_map(visitor),
300 BoltType::Point3D(p) => p.into_deserializer().deserialize_map(visitor),
301 _ => self.unexpected(visitor),
302 }
303 }
304
305 fn deserialize_struct<V>(
306 self,
307 name: &'static str,
308 fields: &'static [&'static str],
309 visitor: V,
310 ) -> Result<V::Value, Self::Error>
311 where
312 V: Visitor<'de>,
313 {
314 match self.value {
315 BoltType::Map(v) => visitor.visit_map(MapDeserializer::new(v.value.iter())),
316 BoltType::Node(v) => v
317 .into_deserializer()
318 .deserialize_struct(name, fields, visitor),
319 BoltType::Relation(v) => v
320 .into_deserializer()
321 .deserialize_struct(name, fields, visitor),
322 BoltType::UnboundedRelation(v) => v
323 .into_deserializer()
324 .deserialize_struct(name, fields, visitor),
325 BoltType::Path(p) => p
326 .into_deserializer()
327 .deserialize_struct(name, fields, visitor),
328 BoltType::Point2D(p) => p
329 .into_deserializer()
330 .deserialize_struct(name, fields, visitor),
331 BoltType::Point3D(p) => p
332 .into_deserializer()
333 .deserialize_struct(name, fields, visitor),
334 BoltType::Duration(d) => visitor.visit_seq(d.seq_access()),
335 _ => self.unexpected(visitor),
336 }
337 }
338
339 fn deserialize_newtype_struct<V>(
340 self,
341 name: &'static str,
342 visitor: V,
343 ) -> Result<V::Value, Self::Error>
344 where
345 V: Visitor<'de>,
346 {
347 match self.value {
348 BoltType::Node(v) => v
349 .into_deserializer()
350 .deserialize_newtype_struct(name, visitor),
351 BoltType::Relation(v) => v
352 .into_deserializer()
353 .deserialize_newtype_struct(name, visitor),
354 BoltType::UnboundedRelation(v) => v
355 .into_deserializer()
356 .deserialize_newtype_struct(name, visitor),
357 BoltType::Path(p) => p
358 .into_deserializer()
359 .deserialize_newtype_struct(name, visitor),
360 BoltType::Point2D(p) => p
361 .into_deserializer()
362 .deserialize_newtype_struct(name, visitor),
363 BoltType::Point3D(p) => p
364 .into_deserializer()
365 .deserialize_newtype_struct(name, visitor),
366 BoltType::Duration(d) => visitor.visit_seq(d.seq_access()),
367 BoltType::DateTimeZoneId(dtz) if name == "Timezone" => {
368 visitor.visit_newtype_struct(BorrowedStrDeserializer::new(dtz.tz_id()))
369 }
370 _ => visitor.visit_newtype_struct(self),
371 }
372 }
373
374 fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
375 where
376 V: Visitor<'de>,
377 {
378 match self.value {
379 BoltType::List(v) if v.len() == len => {
380 visitor.visit_seq(SeqDeserializer::new(v.value.iter()))
381 }
382 BoltType::Point2D(p) => p.into_deserializer().deserialize_tuple(len, visitor),
383 BoltType::Point3D(p) => p.into_deserializer().deserialize_tuple(len, visitor),
384 BoltType::Duration(d) if len == 2 => visitor.visit_seq(d.seq_access()),
385 BoltType::DateTimeZoneId(dtz) => visitor.visit_seq(
386 dtz.seq_access(
387 std::any::type_name::<V>()
388 .contains("TupleVisitor<chrono::naive::datetime::NaiveDateTime,"),
389 ),
390 ),
391 BoltType::LocalTime(t) if len == 2 => visitor.visit_seq(t.seq_access()),
392 BoltType::Time(t) if len == 2 => visitor.visit_seq(t.seq_access()),
393 _ => self.unexpected(visitor),
394 }
395 }
396
397 fn deserialize_tuple_struct<V>(
398 self,
399 _name: &'static str,
400 len: usize,
401 visitor: V,
402 ) -> Result<V::Value, Self::Error>
403 where
404 V: Visitor<'de>,
405 {
406 self.deserialize_tuple(len, visitor)
407 }
408
409 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
410 where
411 V: Visitor<'de>,
412 {
413 match self.value {
414 BoltType::String(v) => visitor.visit_borrowed_str(&v.value),
415 BoltType::Date(_)
416 | BoltType::Time(_)
417 | BoltType::LocalTime(_)
418 | BoltType::DateTime(_)
419 | BoltType::LocalDateTime(_)
420 | BoltType::DateTimeZoneId(_) => self.deserialize_string(visitor),
421 _ => self.unexpected(visitor),
422 }
423 }
424
425 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
426 where
427 V: Visitor<'de>,
428 {
429 match self.value {
430 BoltType::String(v) => visitor.visit_string(v.value.clone()),
431 BoltType::Date(v) => {
432 let date = v.try_to_chrono().map_err(|_| {
433 Error::custom("Could not convert Neo4j Date into chrono::NaiveDate")
434 })?;
435 visitor.visit_string(date.to_string())
436 }
437 BoltType::Time(v) => {
438 let (time, _) = v.to_chrono();
439 visitor.visit_string(time.to_string())
440 }
441 BoltType::LocalTime(v) => {
442 let time = v.to_chrono();
443 visitor.visit_string(time.to_string())
444 }
445 BoltType::DateTime(datetime) => {
446 let datetime = datetime.try_to_chrono().map_err(|_| {
447 Error::custom("Could not convert Neo4j DateTime into chrono::DateTime")
448 })?;
449 let value = match std::any::type_name::<V>() {
450 "chrono::naive::datetime::serde::NaiveDateTimeVisitor" => {
451 format!("{:?}", datetime.naive_local())
452 }
453 _ => datetime.to_rfc3339(),
454 };
455 visitor.visit_string(value)
456 }
457 BoltType::LocalDateTime(ldt) => {
458 let ldt = ldt.try_to_chrono().map_err(|_| {
459 Error::custom(
460 "Could not convert Neo4j LocalDateTime into chrono::NaiveDateTime",
461 )
462 })?;
463 let ldt = format!("{:?}", ldt);
464 visitor.visit_string(ldt)
465 }
466 BoltType::DateTimeZoneId(dtz) => {
467 let dtz = dtz.try_to_chrono().map_err(|_| {
468 Error::custom("Could not convert Neo4j DateTimeZoneId into chrono::DateTime")
469 })?;
470 let value = match std::any::type_name::<V>() {
471 "chrono::naive::datetime::serde::NaiveDateTimeVisitor" => {
472 format!("{:?}", dtz.naive_local())
473 }
474 _ => dtz.to_rfc3339(),
475 };
476 visitor.visit_string(value)
477 }
478 _ => self.unexpected(visitor),
479 }
480 }
481
482 fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
483 where
484 V: Visitor<'de>,
485 {
486 if let BoltType::Bytes(v) = self.value {
487 visitor.visit_borrowed_bytes(&v.value)
488 } else {
489 self.unexpected(visitor)
490 }
491 }
492
493 fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
494 where
495 V: Visitor<'de>,
496 {
497 if let BoltType::Bytes(v) = self.value {
498 visitor.visit_byte_buf(v.value.to_vec())
499 } else {
500 self.unexpected(visitor)
501 }
502 }
503
504 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
505 where
506 V: Visitor<'de>,
507 {
508 if let BoltType::Boolean(v) = self.value {
509 visitor.visit_bool(v.value)
510 } else {
511 self.unexpected(visitor)
512 }
513 }
514
515 fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
516 where
517 V: Visitor<'de>,
518 {
519 let (v, visitor) = self.read_integer(visitor)?;
520 visitor.visit_i8(v)
521 }
522
523 fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
524 where
525 V: Visitor<'de>,
526 {
527 let (v, visitor) = self.read_integer(visitor)?;
528 visitor.visit_i16(v)
529 }
530
531 fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
532 where
533 V: Visitor<'de>,
534 {
535 let (v, visitor) = self.read_integer(visitor)?;
536 visitor.visit_i32(v)
537 }
538
539 fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
540 where
541 V: Visitor<'de>,
542 {
543 let (v, visitor) = self.read_integer(visitor)?;
544 visitor.visit_i64(v)
545 }
546
547 fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
548 where
549 V: Visitor<'de>,
550 {
551 let (v, visitor) = self.read_integer(visitor)?;
552 visitor.visit_u8(v)
553 }
554
555 fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
556 where
557 V: Visitor<'de>,
558 {
559 let (v, visitor) = self.read_integer(visitor)?;
560 visitor.visit_u16(v)
561 }
562
563 fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
564 where
565 V: Visitor<'de>,
566 {
567 let (v, visitor) = self.read_integer(visitor)?;
568 visitor.visit_u32(v)
569 }
570
571 fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
572 where
573 V: Visitor<'de>,
574 {
575 let (v, visitor) = self.read_integer(visitor)?;
576 visitor.visit_u64(v)
577 }
578
579 fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
580 where
581 V: Visitor<'de>,
582 {
583 let (v, visitor) = self.read_float(visitor)?;
584 visitor.visit_f32(v)
585 }
586
587 fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
588 where
589 V: Visitor<'de>,
590 {
591 let (v, visitor) = self.read_float(visitor)?;
592 visitor.visit_f64(v)
593 }
594
595 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
596 where
597 V: Visitor<'de>,
598 {
599 if let BoltType::Null(_) = self.value {
600 visitor.visit_none()
601 } else {
602 visitor.visit_some(self)
603 }
604 }
605
606 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
607 where
608 V: Visitor<'de>,
609 {
610 if let BoltType::Null(_) = self.value {
611 visitor.visit_unit()
612 } else {
613 self.unexpected(visitor)
614 }
615 }
616
617 fn deserialize_unit_struct<V>(
618 self,
619 _name: &'static str,
620 visitor: V,
621 ) -> Result<V::Value, Self::Error>
622 where
623 V: Visitor<'de>,
624 {
625 if let BoltType::Null(_) = self.value {
626 visitor.visit_unit()
627 } else {
628 self.unexpected(visitor)
629 }
630 }
631
632 fn deserialize_enum<V>(
633 self,
634 name: &'static str,
635 _variants: &'static [&'static str],
636 visitor: V,
637 ) -> Result<V::Value, Self::Error>
638 where
639 V: Visitor<'de>,
640 {
641 if name == std::any::type_name::<BoltType>() {
642 visitor.visit_enum(BoltEnum { value: self.value })
643 } else {
644 visitor.visit_enum(CStyleEnum {
645 variant: self.value,
646 })
647 }
648 }
649
650 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
651 where
652 V: Visitor<'de>,
653 {
654 visitor.visit_unit()
655 }
656
657 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
658 where
659 V: Visitor<'de>,
660 {
661 match self.value {
662 BoltType::String(_) => self.deserialize_str(visitor),
663 BoltType::Boolean(_) => self.deserialize_bool(visitor),
664 BoltType::Map(_)
665 | BoltType::Node(_)
666 | BoltType::Relation(_)
667 | BoltType::UnboundedRelation(_)
668 | BoltType::Path(_)
669 | BoltType::Point2D(_)
670 | BoltType::Point3D(_) => self.deserialize_map(visitor),
671 BoltType::Null(_) => self.deserialize_unit(visitor),
672 BoltType::Integer(_) => self.deserialize_i64(visitor),
673 BoltType::Float(_) => self.deserialize_f64(visitor),
674 BoltType::List(_) | BoltType::Bytes(_) => self.deserialize_seq(visitor),
675 BoltType::Date(_)
676 | BoltType::Time(_)
677 | BoltType::LocalTime(_)
678 | BoltType::DateTime(_)
679 | BoltType::LocalDateTime(_)
680 | BoltType::DateTimeZoneId(_) => self.deserialize_string(visitor),
681 BoltType::Duration(_) => self.deserialize_newtype_struct("", visitor),
682 }
683 }
684
685 fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
686 where
687 V: Visitor<'de>,
688 {
689 self.unexpected(visitor)
690 }
691
692 fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
693 where
694 V: Visitor<'de>,
695 {
696 self.unexpected(visitor)
697 }
698
699 fn is_human_readable(&self) -> bool {
700 true
701 }
702}
703
704impl<'de> BoltTypeDeserializer<'de> {
705 fn new(value: &'de BoltType) -> Self {
706 Self { value }
707 }
708
709 fn read_integer<T, E, V>(self, visitor: V) -> Result<(T, V), DeError>
710 where
711 V: Visitor<'de>,
712 i64: TryInto<T, Error = E>,
713 E: Into<std::num::TryFromIntError>,
714 {
715 let integer = match self.value {
716 BoltType::Integer(v) => v.value,
717 BoltType::DateTime(dt) => match dt.try_to_chrono() {
718 Ok(dt) => match std::any::type_name::<V>().rsplit("::").next() {
719 Some("MicroSecondsTimestampVisitor") => dt.timestamp_micros(),
720 Some("MilliSecondsTimestampVisitor") => dt.timestamp_millis(),
721 Some("SecondsTimestampVisitor") => dt.timestamp(),
722 _ => dt.timestamp_nanos(),
723 },
724 Err(_) => return Err(DeError::DateTimeOutOfBounds(std::any::type_name::<T>())),
725 },
726 BoltType::LocalDateTime(ldt) => match ldt.try_to_chrono() {
727 Ok(ldt) => match std::any::type_name::<V>().rsplit("::").next() {
728 Some("MicroSecondsTimestampVisitor") => ldt.timestamp_micros(),
729 Some("MilliSecondsTimestampVisitor") => ldt.timestamp_millis(),
730 Some("SecondsTimestampVisitor") => ldt.timestamp(),
731 _ => ldt.timestamp_nanos(),
732 },
733 Err(_) => return Err(DeError::DateTimeOutOfBounds(std::any::type_name::<T>())),
734 },
735 _ => return self.unexpected(visitor),
736 };
737
738 match integer.try_into() {
739 Ok(v) => Ok((v, visitor)),
740 Err(e) => Err(DeError::IntegerOutOfBounds(
741 e.into(),
742 integer,
743 std::any::type_name::<T>(),
744 )),
745 }
746 }
747
748 fn read_float<T, V>(self, visitor: V) -> Result<(T, V), DeError>
749 where
750 V: Visitor<'de>,
751 T: FromFloat,
752 {
753 if let BoltType::Float(v) = self.value {
754 Ok((T::from_float(v.value), visitor))
755 } else {
756 self.unexpected(visitor)
757 }
758 }
759
760 fn unexpected<V, T>(self, visitor: V) -> Result<T, DeError>
761 where
762 V: Visitor<'de>,
763 {
764 self.value.unexpected(&visitor)
765 }
766}
767
768impl BoltType {
769 fn unexpected<T, E>(&self, expected: &E) -> Result<T, DeError>
770 where
771 E: Expected,
772 {
773 let typ = match self {
774 BoltType::String(v) => Unexp::Str(&v.value),
775 BoltType::Boolean(v) => Unexp::Bool(v.value),
776 BoltType::Map(_) => Unexp::Map,
777 BoltType::Null(_) => Unexp::Unit,
778 BoltType::Integer(v) => Unexp::Signed(v.value),
779 BoltType::Float(v) => Unexp::Float(v.value),
780 BoltType::List(_) => Unexp::Seq,
781 BoltType::Node(_) => Unexp::Map,
782 BoltType::Relation(_) => Unexp::Map,
783 BoltType::UnboundedRelation(_) => Unexp::Map,
784 BoltType::Point2D(_) => Unexp::Other("Point2D"),
785 BoltType::Point3D(_) => Unexp::Other("Point3D"),
786 BoltType::Bytes(v) => Unexp::Bytes(&v.value),
787 BoltType::Path(_) => Unexp::Other("Path"),
788 BoltType::Duration(_) => Unexp::Other("Duration"),
789 BoltType::Date(_) => Unexp::Other("Date"),
790 BoltType::Time(_) => Unexp::Other("Time"),
791 BoltType::LocalTime(_) => Unexp::Other("LocalTime"),
792 BoltType::DateTime(_) => Unexp::Other("DateTime"),
793 BoltType::LocalDateTime(_) => Unexp::Other("LocalDateTime"),
794 BoltType::DateTimeZoneId(_) => Unexp::Other("DateTimeZoneId"),
795 };
796
797 Err(DeError::invalid_type(typ, expected))
798 }
799}
800
801struct BoltEnum<'de> {
802 value: &'de BoltType,
803}
804
805impl<'de> EnumAccess<'de> for BoltEnum<'de> {
806 type Error = DeError;
807
808 type Variant = Self;
809
810 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
811 where
812 V: DeserializeSeed<'de>,
813 {
814 let kind = match self.value {
815 BoltType::String(_) => BoltKind::String,
816 BoltType::Boolean(_) => BoltKind::Boolean,
817 BoltType::Map(_) => BoltKind::Map,
818 BoltType::Null(_) => BoltKind::Null,
819 BoltType::Integer(_) => BoltKind::Integer,
820 BoltType::Float(_) => BoltKind::Float,
821 BoltType::List(_) => BoltKind::List,
822 BoltType::Node(_) => BoltKind::Node,
823 BoltType::Relation(_) => BoltKind::Relation,
824 BoltType::UnboundedRelation(_) => BoltKind::UnboundedRelation,
825 BoltType::Point2D(_) => BoltKind::Point2D,
826 BoltType::Point3D(_) => BoltKind::Point3D,
827 BoltType::Bytes(_) => BoltKind::Bytes,
828 BoltType::Path(_) => BoltKind::Path,
829 BoltType::Duration(_) => BoltKind::Duration,
830 BoltType::Date(_) => BoltKind::Date,
831 BoltType::Time(_) => BoltKind::Time,
832 BoltType::LocalTime(_) => BoltKind::LocalTime,
833 BoltType::DateTime(_) => BoltKind::DateTime,
834 BoltType::LocalDateTime(_) => BoltKind::LocalDateTime,
835 BoltType::DateTimeZoneId(_) => BoltKind::DateTimeZoneId,
836 };
837 let val = seed.deserialize(kind.into_deserializer())?;
838 Ok((val, self))
839 }
840}
841
842impl<'de> VariantAccess<'de> for BoltEnum<'de> {
843 type Error = DeError;
844
845 fn unit_variant(self) -> Result<(), Self::Error> {
846 Err(DeError::invalid_type(Unexp::TupleVariant, &"unit variant"))
847 }
848
849 fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
850 where
851 T: DeserializeSeed<'de>,
852 {
853 Err(DeError::invalid_type(
854 Unexp::TupleVariant,
855 &"newtype variant",
856 ))
857 }
858
859 fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
860 where
861 V: Visitor<'de>,
862 {
863 match self.value {
864 BoltType::String(s) => visitor.visit_borrowed_str(&s.value),
865 BoltType::Boolean(b) => visitor.visit_bool(b.value),
866 BoltType::Map(m) => visitor.visit_map(MapDeserializer::new(m.value.iter())),
867 BoltType::Null(_) => visitor.visit_unit(),
868 BoltType::Integer(i) => visitor.visit_i64(i.value),
869 BoltType::Float(f) => visitor.visit_f64(f.value),
870 BoltType::List(l) => visitor.visit_seq(SeqDeserializer::new(l.value.iter())),
871 BoltType::Node(n) => ElementDataDeserializer::new(n).tuple_variant(len, visitor),
872 BoltType::Relation(r) => ElementDataDeserializer::new(r).tuple_variant(len, visitor),
873 BoltType::UnboundedRelation(r) => {
874 ElementDataDeserializer::new(r).tuple_variant(len, visitor)
875 }
876 BoltType::Point2D(p) => BoltPointDeserializer::new(p).deserialize_tuple(len, visitor),
877 BoltType::Point3D(p) => BoltPointDeserializer::new(p).deserialize_tuple(len, visitor),
878 BoltType::Bytes(b) => visitor.visit_borrowed_bytes(&b.value),
879 BoltType::Path(p) => ElementDataDeserializer::new(p).tuple_variant(len, visitor),
880 BoltType::Duration(d) => visitor.visit_seq(d.seq_access()),
881 BoltType::Date(d) => visitor.visit_map(d.map_access()),
882 BoltType::Time(t) => visitor.visit_map(t.map_access()),
883 BoltType::LocalTime(t) => visitor.visit_map(t.map_access()),
884 BoltType::DateTime(dt) => visitor.visit_map(dt.map_access()),
885 BoltType::LocalDateTime(dt) => visitor.visit_map(dt.map_access()),
886 BoltType::DateTimeZoneId(dt) => visitor.visit_map(dt.map_access()),
887 }
888 }
889
890 fn struct_variant<V>(
891 self,
892 _fields: &'static [&'static str],
893 _visitor: V,
894 ) -> Result<V::Value, Self::Error>
895 where
896 V: Visitor<'de>,
897 {
898 Err(DeError::invalid_type(
899 Unexp::TupleVariant,
900 &"struct variant",
901 ))
902 }
903}
904
905struct CStyleEnum<'de> {
906 variant: &'de BoltType,
907}
908
909impl<'de> EnumAccess<'de> for CStyleEnum<'de> {
910 type Error = DeError;
911
912 type Variant = UnitVariant;
913
914 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
915 where
916 V: DeserializeSeed<'de>,
917 {
918 let val = match self.variant {
919 BoltType::String(variant) => seed.deserialize(variant.into_deserializer())?,
920 BoltType::Bytes(variant) => seed.deserialize(variant.into_deserializer())?,
921 BoltType::Integer(variant) => seed.deserialize(variant.value.into_deserializer())?,
922 otherwise => {
923 otherwise.unexpected(&"string, bytes, or integer (valid enum identifier)")?
924 }
925 };
926
927 Ok((val, UnitVariant))
928 }
929}
930
931struct UnitVariant;
932
933impl<'de> VariantAccess<'de> for UnitVariant {
934 type Error = DeError;
935
936 fn unit_variant(self) -> Result<(), Self::Error> {
937 Ok(())
938 }
939
940 fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
941 where
942 T: DeserializeSeed<'de>,
943 {
944 Err(DeError::invalid_type(
945 Unexp::NewtypeVariant,
946 &"unit variant",
947 ))
948 }
949
950 fn tuple_variant<V>(self, _len: usize, _visitorr: V) -> Result<V::Value, Self::Error>
951 where
952 V: Visitor<'de>,
953 {
954 Err(DeError::invalid_type(Unexp::TupleVariant, &"unit variant"))
955 }
956
957 fn struct_variant<V>(
958 self,
959 _fields: &'static [&'static str],
960 _visitor: V,
961 ) -> Result<V::Value, Self::Error>
962 where
963 V: Visitor<'de>,
964 {
965 Err(DeError::invalid_type(Unexp::StructVariant, &"unit variant"))
966 }
967}
968
969impl<'de> IntoDeserializer<'de, DeError> for &'de BoltType {
970 type Deserializer = BoltTypeDeserializer<'de>;
971
972 fn into_deserializer(self) -> Self::Deserializer {
973 BoltTypeDeserializer::new(self)
974 }
975}
976
977impl<'de> IntoDeserializer<'de, DeError> for &'de BoltString {
978 type Deserializer = BorrowedStrDeserializer<'de, DeError>;
979
980 fn into_deserializer(self) -> Self::Deserializer {
981 BorrowedStrDeserializer::new(&self.value)
982 }
983}
984
985impl<'de> IntoDeserializer<'de, DeError> for &'de BoltBytes {
986 type Deserializer = BorrowedBytesDeserializer<'de, DeError>;
987
988 fn into_deserializer(self) -> Self::Deserializer {
989 BorrowedBytesDeserializer::new(&self.value)
990 }
991}
992
993trait FromFloat {
994 fn from_float(f: f64) -> Self;
995}
996
997impl FromFloat for f32 {
998 fn from_float(f: f64) -> Self {
999 f as f32
1000 }
1001}
1002
1003impl FromFloat for f64 {
1004 fn from_float(f: f64) -> Self {
1005 f
1006 }
1007}
1008
1009#[cfg(test)]
1010mod tests {
1011 use std::{borrow::Cow, collections::HashMap, fmt::Debug, net::SocketAddr, time::Duration};
1012
1013 use super::*;
1014
1015 use crate::{
1016 types::{
1017 BoltDate, BoltDateTime, BoltDateTimeZoneId, BoltDuration, BoltInteger,
1018 BoltLocalDateTime, BoltLocalTime, BoltMap, BoltNode, BoltNull, BoltPoint2D,
1019 BoltPoint3D, BoltRelation, BoltTime, BoltUnboundedRelation,
1020 },
1021 EndNodeId, Id, Keys, Labels, Node, Offset, Row, StartNodeId, Timezone, Type,
1022 };
1023
1024 use chrono::{DateTime, FixedOffset, NaiveDate, NaiveDateTime, NaiveTime, Timelike, Utc};
1025 use serde::Deserialize;
1026
1027 #[test]
1028 fn map_with_extra_fields() {
1029 #[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
1030 struct Person {
1031 name: String,
1032 age: u8,
1033 }
1034
1035 let map = [
1036 (BoltString::from("name"), BoltType::from("Alice")),
1037 (BoltString::from("age"), BoltType::from(42)),
1038 (BoltString::from("bar"), BoltType::from(1337)),
1039 ]
1040 .into_iter()
1041 .collect::<BoltMap>();
1042 let map = BoltType::Map(map);
1043
1044 let actual = map.to::<Person>().unwrap();
1045 let expected = Person {
1046 name: "Alice".into(),
1047 age: 42,
1048 };
1049
1050 assert_eq!(actual, expected);
1051 }
1052
1053 #[test]
1054 fn map_with_extra_fields_fails_for_deny_unknown_fields() {
1055 #[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
1056 #[serde(deny_unknown_fields)]
1057 struct Person {
1058 name: String,
1059 age: u8,
1060 }
1061
1062 let map = [
1063 (BoltString::from("name"), BoltType::from("Alice")),
1064 (BoltString::from("age"), BoltType::from(42)),
1065 (BoltString::from("bar"), BoltType::from(1337)),
1066 ]
1067 .into_iter()
1068 .collect::<BoltMap>();
1069 let map = BoltType::Map(map);
1070
1071 assert!(map.to::<Person>().is_err());
1072 }
1073
1074 #[test]
1075 fn simple_struct() {
1076 #[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
1077 struct Person {
1078 name: String,
1079 age: u8,
1080 }
1081
1082 let map = [
1083 (BoltString::from("name"), BoltType::from("Alice")),
1084 (BoltString::from("age"), BoltType::from(42)),
1085 ]
1086 .into_iter()
1087 .collect::<BoltMap>();
1088
1089 let actual = map.to::<Person>().unwrap();
1090 let expected = Person {
1091 name: "Alice".into(),
1092 age: 42,
1093 };
1094
1095 assert_eq!(actual, expected);
1096 }
1097
1098 #[test]
1099 fn struct_with_null_value() {
1100 #[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
1101 struct Person {
1102 name: String,
1103 age: Option<u8>,
1104 }
1105
1106 let map = [
1107 (BoltString::from("name"), BoltType::from("Alice")),
1108 (BoltString::from("age"), BoltType::Null(BoltNull)),
1109 ]
1110 .into_iter()
1111 .collect::<BoltMap>();
1112
1113 let actual = map.to::<Person>().unwrap();
1114 let expected = Person {
1115 name: "Alice".into(),
1116 age: None,
1117 };
1118
1119 assert_eq!(actual, expected);
1120 }
1121
1122 #[test]
1123 fn tuple_struct_from_list() {
1124 #[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
1125 struct Person(String, u8);
1126
1127 let list = BoltType::from(vec![BoltType::from("Alice"), BoltType::from(42)]);
1128 let actual = list.to::<Person>().unwrap();
1129 let expected = Person("Alice".into(), 42);
1130
1131 assert_eq!(actual, expected);
1132 }
1133
1134 #[test]
1135 fn tuple_struct_from_map_fails() {
1136 #[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
1140 struct Person(String, u8);
1141
1142 let map = [
1143 (BoltString::from("name"), BoltType::from("Alice")),
1144 (BoltString::from("age"), BoltType::from(42)),
1145 ]
1146 .into_iter()
1147 .collect::<BoltMap>();
1148
1149 let map = BoltType::Map(map);
1150
1151 assert!(map.to::<Person>().is_err());
1152 }
1153
1154 #[test]
1155 fn node() {
1156 #[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
1157 struct Person {
1158 id: Id,
1159 labels: Labels,
1160 keys: Keys,
1161 name: String,
1162 age: u8,
1163 }
1164
1165 let id = BoltInteger::new(1337);
1166 let labels = vec!["Person".into()].into();
1167 let properties = vec![
1168 ("name".into(), "Alice".into()),
1169 ("age".into(), 42_u16.into()),
1170 ]
1171 .into_iter()
1172 .collect();
1173
1174 let node = BoltNode {
1175 id,
1176 labels,
1177 properties,
1178 };
1179 let node = BoltType::Node(node);
1180
1181 let actual = node.to::<Person>().unwrap();
1182 let expected = Person {
1183 id: Id(1337),
1184 labels: Labels(vec!["Person".into()]),
1185 keys: Keys(["name".into(), "age".into()].into()),
1186 name: "Alice".into(),
1187 age: 42,
1188 };
1189 assert_eq!(actual, expected);
1190 }
1191
1192 #[test]
1193 fn relation() {
1194 #[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
1195 struct Person {
1196 id: Id,
1197 start: StartNodeId,
1198 end: EndNodeId,
1199 typ: Type,
1200 keys: Keys,
1201 name: String,
1202 age: u8,
1203 }
1204
1205 let id = BoltInteger::new(1337);
1206 let start_node_id = BoltInteger::new(21);
1207 let end_node_id = BoltInteger::new(84);
1208 let typ = "Person".into();
1209 let properties = vec![
1210 ("name".into(), "Alice".into()),
1211 ("age".into(), 42_u16.into()),
1212 ]
1213 .into_iter()
1214 .collect();
1215
1216 let relation = BoltRelation {
1217 id,
1218 start_node_id,
1219 end_node_id,
1220 properties,
1221 typ,
1222 };
1223 let relation = BoltType::Relation(relation);
1224
1225 let actual = relation.to::<Person>().unwrap();
1226 let expected = Person {
1227 id: Id(1337),
1228 start: StartNodeId(21),
1229 end: EndNodeId(84),
1230 typ: Type("Person".into()),
1231 keys: Keys(["name".into(), "age".into()].into()),
1232 name: "Alice".into(),
1233 age: 42,
1234 };
1235 assert_eq!(actual, expected);
1236 }
1237
1238 #[test]
1239 fn unbounded_relation() {
1240 #[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
1241 struct Person {
1242 id: Id,
1243 typ: Type,
1244 keys: Keys,
1245 name: String,
1246 age: u8,
1247 }
1248
1249 let id = BoltInteger::new(1337);
1250 let typ = "Person".into();
1251 let properties = vec![
1252 ("name".into(), "Alice".into()),
1253 ("age".into(), 42_u16.into()),
1254 ]
1255 .into_iter()
1256 .collect();
1257
1258 let relation = BoltUnboundedRelation {
1259 id,
1260 properties,
1261 typ,
1262 };
1263 let relation = BoltType::UnboundedRelation(relation);
1264
1265 let actual = relation.to::<Person>().unwrap();
1266 let expected = Person {
1267 id: Id(1337),
1268 typ: Type("Person".into()),
1269 keys: Keys(["name".into(), "age".into()].into()),
1270 name: "Alice".into(),
1271 age: 42,
1272 };
1273 assert_eq!(actual, expected);
1274 }
1275
1276 #[test]
1277 fn tuple() {
1278 let list = BoltType::from(vec![BoltType::from("Alice"), BoltType::from(42)]);
1279 let actual = list.to::<(String, u8)>().unwrap();
1280 let expected = ("Alice".into(), 42);
1281
1282 assert_eq!(actual, expected);
1283 }
1284
1285 #[test]
1286 fn borrowing_struct() {
1287 #[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
1288 struct Person<'a> {
1289 name: &'a str,
1290 age: u8,
1291 }
1292
1293 let map = [
1294 (BoltString::from("name"), BoltType::from("Alice")),
1295 (BoltString::from("age"), BoltType::from(42)),
1296 ]
1297 .into_iter()
1298 .collect::<BoltMap>();
1299
1300 let actual = map.to::<Person>().unwrap();
1301 let expected = Person {
1302 name: "Alice",
1303 age: 42,
1304 };
1305
1306 assert_eq!(actual, expected);
1307 }
1308
1309 #[test]
1310 fn various_types() {
1311 #[derive(Clone, Debug, PartialEq, Deserialize)]
1312 struct Bag<'a> {
1313 borrowed: &'a str,
1314 owned: String,
1315
1316 float: f64,
1317 int: i32,
1318 long: i64,
1319
1320 boolean: bool,
1321
1322 unit: (),
1323 }
1324
1325 let map = [
1326 (
1327 BoltString::from("borrowed"),
1328 BoltType::from("I am borrowed"),
1329 ),
1330 (
1331 BoltString::from("owned"),
1332 BoltType::from("I am cloned and owned"),
1333 ),
1334 (BoltString::from("float"), BoltType::from(13.37)),
1335 (BoltString::from("int"), BoltType::from(42_i32)),
1336 (BoltString::from("long"), BoltType::from(1337_i64)),
1337 (BoltString::from("boolean"), BoltType::from(true)),
1338 (BoltString::from("unit"), BoltType::Null(BoltNull)),
1339 ]
1340 .into_iter()
1341 .collect::<BoltMap>();
1342
1343 let actual = map.to::<Bag>().unwrap();
1344 let expected = Bag {
1345 borrowed: "I am borrowed",
1346 owned: "I am cloned and owned".to_owned(),
1347 float: 13.37,
1348 int: 42,
1349 long: 1337,
1350 boolean: true,
1351 unit: (),
1352 };
1353
1354 assert_eq!(actual, expected);
1355 }
1356
1357 #[test]
1358 fn std_bytes() {
1359 #[derive(Clone, Debug, PartialEq, Deserialize)]
1360 struct Bytes<'a> {
1361 bytes: Vec<u8>,
1362 slice: &'a [u8],
1363 }
1364
1365 let map = [
1366 (BoltString::from("bytes"), BoltType::from(vec![4_u8, 2])),
1367 (
1368 BoltString::from("slice"),
1369 BoltType::from(vec![1_u8, 3, 3, 7]),
1370 ),
1371 ]
1372 .into_iter()
1373 .collect::<BoltMap>();
1374
1375 let actual = map.to::<Bytes>().unwrap();
1376 let expected = Bytes {
1377 bytes: vec![4, 2],
1378 slice: &[1, 3, 3, 7],
1379 };
1380
1381 assert_eq!(actual, expected);
1382 }
1383
1384 #[test]
1385 fn serde_bytes_bytes() {
1386 #[derive(Clone, Debug, PartialEq, Deserialize)]
1387 struct Bytes<'a> {
1388 #[serde(with = "serde_bytes")]
1389 bytes: Vec<u8>,
1390 #[serde(with = "serde_bytes")]
1391 slice: &'a [u8],
1392 }
1393
1394 let map = [
1395 (BoltString::from("bytes"), BoltType::from(vec![4_u8, 2])),
1396 (
1397 BoltString::from("slice"),
1398 BoltType::from(vec![1_u8, 3, 3, 7]),
1399 ),
1400 ]
1401 .into_iter()
1402 .collect::<BoltMap>();
1403
1404 let actual = map.to::<Bytes>().unwrap();
1405 let expected = Bytes {
1406 bytes: vec![4, 2],
1407 slice: &[1, 3, 3, 7],
1408 };
1409
1410 assert_eq!(actual, expected);
1411 }
1412
1413 #[test]
1414 fn serde_with_bytes() {
1415 use serde_with::{serde_as, Bytes};
1416
1417 #[serde_as]
1418 #[derive(Clone, Debug, PartialEq, Deserialize)]
1419 struct AsBytes<'a> {
1420 #[serde_as(as = "Bytes")]
1421 array: [u8; 4],
1422
1423 #[serde_as(as = "Bytes")]
1424 boxed: Box<[u8]>,
1425
1426 #[serde_as(as = "Bytes")]
1427 #[serde(borrow)]
1428 cow: Cow<'a, [u8]>,
1429
1430 #[serde_as(as = "Bytes")]
1431 #[serde(borrow)]
1432 cow_array: Cow<'a, [u8; 2]>,
1433
1434 #[serde_as(as = "Bytes")]
1435 bytes: Vec<u8>,
1436
1437 #[serde_as(as = "Bytes")]
1438 slice: &'a [u8],
1439 }
1440
1441 let map = [
1442 (
1443 BoltString::from("array"),
1444 BoltType::from(vec![1_u8, 3, 3, 7]),
1445 ),
1446 (BoltString::from("boxed"), BoltType::from(vec![4_u8, 2])),
1447 (BoltString::from("cow"), BoltType::from(vec![1_u8, 3, 3, 7])),
1448 (BoltString::from("cow_array"), BoltType::from(vec![4_u8, 2])),
1449 (
1450 BoltString::from("bytes"),
1451 BoltType::from(vec![1_u8, 3, 3, 7]),
1452 ),
1453 (BoltString::from("slice"), BoltType::from(vec![4_u8, 2])),
1454 ]
1455 .into_iter()
1456 .collect::<BoltMap>();
1457
1458 let actual = map.to::<AsBytes>().unwrap();
1459 let expected = AsBytes {
1460 array: [1, 3, 3, 7],
1461 boxed: vec![4, 2].into_boxed_slice(),
1462 cow: vec![1_u8, 3, 3, 7].into(),
1463 cow_array: Cow::Owned([4_u8, 2]),
1464 bytes: vec![1, 3, 3, 7],
1465 slice: &[4, 2],
1466 };
1467
1468 assert_eq!(actual, expected);
1469 }
1470
1471 #[test]
1472 fn nested_struct() {
1473 #[derive(Clone, Debug, PartialEq, Deserialize)]
1474 struct Person {
1475 name: String,
1476 age: u32,
1477 }
1478
1479 #[derive(Clone, Debug, PartialEq, Deserialize)]
1480 struct Couple {
1481 p0: Person,
1482 p1: Person,
1483 }
1484
1485 let map = [
1486 (
1487 BoltString::from("p0"),
1488 BoltType::Map(
1489 [
1490 (BoltString::from("name"), BoltType::from("Alice")),
1491 (BoltString::from("age"), BoltType::from(42)),
1492 ]
1493 .into_iter()
1494 .collect(),
1495 ),
1496 ),
1497 (
1498 BoltString::from("p1"),
1499 BoltType::Map(
1500 [
1501 (BoltString::from("name"), BoltType::from("Bob")),
1502 (BoltString::from("age"), BoltType::from(1337)),
1503 ]
1504 .into_iter()
1505 .collect(),
1506 ),
1507 ),
1508 ]
1509 .into_iter()
1510 .collect::<BoltMap>();
1511
1512 let actual = map.to::<Couple>().unwrap();
1513 let expected = Couple {
1514 p0: Person {
1515 name: "Alice".into(),
1516 age: 42,
1517 },
1518 p1: Person {
1519 name: "Bob".into(),
1520 age: 1337,
1521 },
1522 };
1523
1524 assert_eq!(actual, expected);
1525 }
1526
1527 #[test]
1528 fn list() {
1529 let list = BoltType::from(vec![42_i64, 1337]);
1530 let actual = list.to::<Vec<i64>>().unwrap();
1531
1532 assert_eq!(actual, vec![42_i64, 1337]);
1533 }
1534
1535 #[test]
1536 fn nested_list() {
1537 #[derive(Debug, Deserialize, PartialEq)]
1538 struct Foo {
1539 bars: Vec<i64>,
1540 }
1541
1542 let data = [(BoltString::from("bars"), BoltType::from(vec![42, 1337]))]
1543 .into_iter()
1544 .collect::<BoltMap>();
1545 let actual = data.to::<Foo>().unwrap();
1546 let expected = Foo {
1547 bars: vec![42, 1337],
1548 };
1549
1550 assert_eq!(actual, expected);
1551 }
1552
1553 fn test_datetime() -> DateTime<FixedOffset> {
1554 DateTime::parse_from_rfc3339("1999-07-14T13:37:42+02:00").unwrap()
1555 }
1556
1557 #[test]
1558 fn datetime() {
1559 let expected = test_datetime();
1560
1561 let datetime = BoltDateTime::from(expected);
1562 let datetime = BoltType::DateTime(datetime);
1563
1564 let actual = datetime.to::<DateTime<FixedOffset>>().unwrap();
1565 assert_eq!(actual, expected);
1566 }
1567
1568 #[test]
1569 fn datetime_nanoseconds() {
1570 #[derive(Debug, PartialEq, Deserialize)]
1571 #[serde(transparent)]
1572 struct S {
1573 #[serde(with = "chrono::serde::ts_nanoseconds")]
1574 datetime: DateTime<Utc>,
1575 }
1576
1577 let expected = test_datetime();
1578
1579 let datetime = BoltDateTime::from(expected);
1580 let datetime = BoltType::DateTime(datetime);
1581
1582 let actual = datetime.to::<S>().unwrap().datetime;
1583 assert_eq!(actual, expected);
1584 }
1585
1586 #[test]
1587 fn datetime_opt_nanoseconds() {
1588 #[derive(Debug, PartialEq, Deserialize)]
1589 #[serde(transparent)]
1590 struct S {
1591 #[serde(with = "chrono::serde::ts_nanoseconds_option")]
1592 datetime: Option<DateTime<Utc>>,
1593 }
1594
1595 let expected = test_datetime();
1596
1597 let datetime = BoltDateTime::from(expected);
1598 let datetime = BoltType::DateTime(datetime);
1599
1600 let actual = datetime.to::<S>().unwrap().datetime.unwrap();
1601 assert_eq!(actual, expected);
1602 }
1603
1604 #[test]
1605 fn datetime_microseconds() {
1606 #[derive(Debug, PartialEq, Deserialize)]
1607 #[serde(transparent)]
1608 struct S {
1609 #[serde(with = "chrono::serde::ts_microseconds")]
1610 datetime: DateTime<Utc>,
1611 }
1612
1613 let expected = test_datetime();
1614
1615 let datetime = BoltDateTime::from(expected);
1616 let datetime = BoltType::DateTime(datetime);
1617
1618 let actual = datetime.to::<S>().unwrap().datetime;
1619 assert_eq!(actual, expected);
1620 }
1621
1622 #[test]
1623 fn datetime_opt_microseconds() {
1624 #[derive(Debug, PartialEq, Deserialize)]
1625 #[serde(transparent)]
1626 struct S {
1627 #[serde(with = "chrono::serde::ts_microseconds_option")]
1628 datetime: Option<DateTime<Utc>>,
1629 }
1630
1631 let expected = test_datetime();
1632
1633 let datetime = BoltDateTime::from(expected);
1634 let datetime = BoltType::DateTime(datetime);
1635
1636 let actual = datetime.to::<S>().unwrap().datetime.unwrap();
1637 assert_eq!(actual, expected);
1638 }
1639
1640 #[test]
1641 fn datetime_milliseconds() {
1642 #[derive(Debug, PartialEq, Deserialize)]
1643 #[serde(transparent)]
1644 struct S {
1645 #[serde(with = "chrono::serde::ts_milliseconds")]
1646 datetime: DateTime<Utc>,
1647 }
1648
1649 let expected = test_datetime();
1650
1651 let datetime = BoltDateTime::from(expected);
1652 let datetime = BoltType::DateTime(datetime);
1653
1654 let actual = datetime.to::<S>().unwrap().datetime;
1655 assert_eq!(actual, expected);
1656 }
1657
1658 #[test]
1659 fn datetime_opt_milliseconds() {
1660 #[derive(Debug, PartialEq, Deserialize)]
1661 #[serde(transparent)]
1662 struct S {
1663 #[serde(with = "chrono::serde::ts_milliseconds_option")]
1664 datetime: Option<DateTime<Utc>>,
1665 }
1666
1667 let expected = test_datetime();
1668
1669 let datetime = BoltDateTime::from(expected);
1670 let datetime = BoltType::DateTime(datetime);
1671
1672 let actual = datetime.to::<S>().unwrap().datetime.unwrap();
1673 assert_eq!(actual, expected);
1674 }
1675
1676 #[test]
1677 fn datetime_seconds() {
1678 #[derive(Debug, PartialEq, Deserialize)]
1679 #[serde(transparent)]
1680 struct S {
1681 #[serde(with = "chrono::serde::ts_seconds")]
1682 datetime: DateTime<Utc>,
1683 }
1684
1685 let expected = test_datetime();
1686
1687 let datetime = BoltDateTime::from(expected);
1688 let datetime = BoltType::DateTime(datetime);
1689
1690 let actual = datetime.to::<S>().unwrap().datetime;
1691 assert_eq!(actual, expected);
1692 }
1693
1694 #[test]
1695 fn datetime_opt_seconds() {
1696 #[derive(Debug, PartialEq, Deserialize)]
1697 #[serde(transparent)]
1698 struct S {
1699 #[serde(with = "chrono::serde::ts_seconds_option")]
1700 datetime: Option<DateTime<Utc>>,
1701 }
1702
1703 let expected = test_datetime();
1704
1705 let datetime = BoltDateTime::from(expected);
1706 let datetime = BoltType::DateTime(datetime);
1707
1708 let actual = datetime.to::<S>().unwrap().datetime.unwrap();
1709 assert_eq!(actual, expected);
1710 }
1711
1712 fn test_local_datetime() -> NaiveDateTime {
1713 NaiveDate::from_ymd_opt(1999, 7, 14)
1714 .unwrap()
1715 .and_hms_nano_opt(13, 37, 42, 421337420)
1716 .unwrap()
1717 }
1718
1719 #[test]
1720 fn local_datetime() {
1721 let expected = test_local_datetime();
1722
1723 let local_datetime = BoltLocalDateTime::from(test_local_datetime());
1724 let local_datetime = BoltType::LocalDateTime(local_datetime);
1725
1726 let actual = local_datetime.to::<NaiveDateTime>().unwrap();
1727 assert_eq!(actual, expected);
1728 }
1729
1730 #[test]
1731 fn local_datetime_nanoseconds() {
1732 #[derive(Debug, PartialEq, Deserialize)]
1733 #[serde(transparent)]
1734 struct S {
1735 #[serde(with = "chrono::naive::serde::ts_nanoseconds")]
1736 local_datetime: NaiveDateTime,
1737 }
1738
1739 let expected = test_local_datetime();
1740
1741 let local_datetime = BoltLocalDateTime::from(test_local_datetime());
1742 let local_datetime = BoltType::LocalDateTime(local_datetime);
1743
1744 let actual = local_datetime.to::<S>().unwrap().local_datetime;
1745 assert_eq!(actual, expected);
1746 }
1747
1748 #[test]
1749 fn local_datetime_opt_nanoseconds() {
1750 #[derive(Debug, PartialEq, Deserialize)]
1751 #[serde(transparent)]
1752 struct S {
1753 #[serde(with = "chrono::naive::serde::ts_nanoseconds_option")]
1754 local_datetime: Option<NaiveDateTime>,
1755 }
1756
1757 let expected = test_local_datetime();
1758
1759 let local_datetime = BoltLocalDateTime::from(test_local_datetime());
1760 let local_datetime = BoltType::LocalDateTime(local_datetime);
1761
1762 let actual = local_datetime.to::<S>().unwrap().local_datetime.unwrap();
1763 assert_eq!(actual, expected);
1764 }
1765
1766 #[test]
1767 fn local_datetime_microseconds() {
1768 #[derive(Debug, PartialEq, Deserialize)]
1769 #[serde(transparent)]
1770 struct S {
1771 #[serde(with = "chrono::naive::serde::ts_microseconds")]
1772 local_datetime: NaiveDateTime,
1773 }
1774
1775 let expected = test_local_datetime().with_nanosecond(421337000).unwrap();
1776
1777 let local_datetime = BoltLocalDateTime::from(test_local_datetime());
1778 let local_datetime = BoltType::LocalDateTime(local_datetime);
1779
1780 let actual = local_datetime.to::<S>().unwrap().local_datetime;
1781 assert_eq!(actual, expected);
1782 }
1783
1784 #[test]
1785 fn local_datetime_opt_microseconds() {
1786 #[derive(Debug, PartialEq, Deserialize)]
1787 #[serde(transparent)]
1788 struct S {
1789 #[serde(with = "chrono::naive::serde::ts_microseconds_option")]
1790 local_datetime: Option<NaiveDateTime>,
1791 }
1792
1793 let expected = test_local_datetime().with_nanosecond(421337000).unwrap();
1794
1795 let local_datetime = BoltLocalDateTime::from(test_local_datetime());
1796 let local_datetime = BoltType::LocalDateTime(local_datetime);
1797
1798 let actual = local_datetime.to::<S>().unwrap().local_datetime.unwrap();
1799 assert_eq!(actual, expected);
1800 }
1801
1802 #[test]
1803 fn local_datetime_milliseconds() {
1804 #[derive(Debug, PartialEq, Deserialize)]
1805 #[serde(transparent)]
1806 struct S {
1807 #[serde(with = "chrono::naive::serde::ts_milliseconds")]
1808 local_datetime: NaiveDateTime,
1809 }
1810
1811 let expected = test_local_datetime().with_nanosecond(421000000).unwrap();
1812
1813 let local_datetime = BoltLocalDateTime::from(test_local_datetime());
1814 let local_datetime = BoltType::LocalDateTime(local_datetime);
1815
1816 let actual = local_datetime.to::<S>().unwrap().local_datetime;
1817 assert_eq!(actual, expected);
1818 }
1819
1820 #[test]
1821 fn local_datetime_opt_milliseconds() {
1822 #[derive(Debug, PartialEq, Deserialize)]
1823 #[serde(transparent)]
1824 struct S {
1825 #[serde(with = "chrono::naive::serde::ts_milliseconds_option")]
1826 local_datetime: Option<NaiveDateTime>,
1827 }
1828
1829 let expected = test_local_datetime().with_nanosecond(421000000).unwrap();
1830
1831 let local_datetime = BoltLocalDateTime::from(test_local_datetime());
1832 let local_datetime = BoltType::LocalDateTime(local_datetime);
1833
1834 let actual = local_datetime.to::<S>().unwrap().local_datetime.unwrap();
1835 assert_eq!(actual, expected);
1836 }
1837
1838 #[test]
1839 fn local_datetime_seconds() {
1840 #[derive(Debug, PartialEq, Deserialize)]
1841 #[serde(transparent)]
1842 struct S {
1843 #[serde(with = "chrono::naive::serde::ts_seconds")]
1844 local_datetime: NaiveDateTime,
1845 }
1846
1847 let expected = test_local_datetime().with_nanosecond(0).unwrap();
1848
1849 let local_datetime = BoltLocalDateTime::from(test_local_datetime());
1850 let local_datetime = BoltType::LocalDateTime(local_datetime);
1851
1852 let actual = local_datetime.to::<S>().unwrap().local_datetime;
1853 assert_eq!(actual, expected);
1854 }
1855
1856 #[test]
1857 fn local_datetime_opt_seconds() {
1858 #[derive(Debug, PartialEq, Deserialize)]
1859 #[serde(transparent)]
1860 struct S {
1861 #[serde(with = "chrono::naive::serde::ts_seconds_option")]
1862 local_datetime: Option<NaiveDateTime>,
1863 }
1864
1865 let expected = test_local_datetime().with_nanosecond(0).unwrap();
1866
1867 let local_datetime = BoltLocalDateTime::from(test_local_datetime());
1868 let local_datetime = BoltType::LocalDateTime(local_datetime);
1869
1870 let actual = local_datetime.to::<S>().unwrap().local_datetime.unwrap();
1871 assert_eq!(actual, expected);
1872 }
1873
1874 fn test_datetime_tz() -> DateTime<FixedOffset> {
1875 test_local_datetime()
1876 .and_local_timezone(FixedOffset::east_opt(2 * 3600).unwrap())
1877 .unwrap()
1878 }
1879
1880 #[test]
1881 fn datetime_tz() {
1882 let expected = test_datetime_tz();
1883
1884 let datetime_tz = BoltDateTimeZoneId::from((test_local_datetime(), "Europe/Paris"));
1885 let datetime_tz = BoltType::DateTimeZoneId(datetime_tz);
1886
1887 let actual = datetime_tz.to::<DateTime<FixedOffset>>().unwrap();
1888 assert_eq!(actual, expected);
1889 }
1890
1891 #[test]
1892 fn datetime_tz_info() {
1893 let datetime_tz = BoltDateTimeZoneId::from((test_local_datetime(), "Europe/Paris"));
1894 let datetime_tz = BoltType::DateTimeZoneId(datetime_tz);
1895
1896 let actual = datetime_tz.to::<Timezone>().unwrap().0;
1897 assert_eq!(actual, "Europe/Paris");
1898 }
1899
1900 #[test]
1901 fn datetime_tz_with_info() {
1902 let expected = test_datetime_tz();
1903
1904 let datetime_tz = BoltDateTimeZoneId::from((test_local_datetime(), "Europe/Paris"));
1905 let datetime_tz = BoltType::DateTimeZoneId(datetime_tz);
1906
1907 let (datetime, timezone) = datetime_tz.to::<(DateTime<FixedOffset>, String)>().unwrap();
1908
1909 assert_eq!(datetime, expected);
1910 assert_eq!(timezone, "Europe/Paris");
1911 }
1912
1913 #[test]
1914 fn datetime_as_naive_datetime() {
1915 let expected = test_datetime().naive_local();
1916
1917 let datetime = BoltDateTime::from(test_datetime());
1918 let datetime = BoltType::DateTime(datetime);
1919
1920 let datetime = datetime.to::<NaiveDateTime>().unwrap();
1921
1922 assert_eq!(datetime, expected);
1923 }
1924
1925 #[test]
1926 fn datetime_tz_as_naive_datetime() {
1927 let expected = test_datetime_tz().naive_local();
1928
1929 let datetime = BoltDateTimeZoneId::from((test_local_datetime(), "Europe/Paris"));
1930 let datetime = BoltType::DateTimeZoneId(datetime);
1931
1932 let datetime = datetime.to::<NaiveDateTime>().unwrap();
1933
1934 assert_eq!(datetime, expected);
1935 }
1936
1937 #[test]
1938 fn datetime_tz_as_naive_datetime_with_tz_info() {
1939 let expected = test_datetime_tz().naive_local();
1940
1941 let datetime = BoltDateTimeZoneId::from((test_local_datetime(), "Europe/Paris"));
1942 let datetime = BoltType::DateTimeZoneId(datetime);
1943
1944 let (datetime, tz) = datetime.to::<(NaiveDateTime, String)>().unwrap();
1945
1946 assert_eq!(datetime, expected);
1947 assert_eq!(tz, "Europe/Paris");
1948 }
1949
1950 #[test]
1951 fn point_2d() {
1952 #[derive(Debug, PartialEq, Deserialize)]
1953 struct P {
1954 x: f64,
1955 y: f64,
1956 }
1957
1958 let point = BoltType::Point2D(BoltPoint2D {
1959 sr_id: 420.into(),
1960 x: BoltFloat::new(42.0),
1961 y: BoltFloat::new(13.37),
1962 });
1963
1964 let actual = point.to::<P>().unwrap();
1965 let expected = P { x: 42.0, y: 13.37 };
1966
1967 assert_eq!(actual, expected);
1968 }
1969
1970 #[test]
1971 fn point_3d() {
1972 #[derive(Debug, PartialEq, Deserialize)]
1973 struct P {
1974 x: f64,
1975 y: f64,
1976 z: f64,
1977 }
1978
1979 let point = BoltType::Point3D(BoltPoint3D {
1980 sr_id: 420.into(),
1981 x: BoltFloat::new(42.0),
1982 y: BoltFloat::new(13.37),
1983 z: BoltFloat::new(84.0),
1984 });
1985 let actual = point.to::<P>().unwrap();
1986 let expected = P {
1987 x: 42.0,
1988 y: 13.37,
1989 z: 84.0,
1990 };
1991
1992 assert_eq!(actual, expected);
1993 }
1994
1995 #[test]
1996 fn duration() {
1997 let duration = Duration::new(42, 1337);
1998
1999 let bolt = BoltType::Duration(BoltDuration::from(duration));
2000
2001 let actual = bolt.to::<std::time::Duration>().unwrap();
2002 assert_eq!(actual, duration);
2003
2004 let actual = bolt.to::<time::Duration>().unwrap();
2005 assert_eq!(actual, duration);
2006 }
2007
2008 fn test_date() -> NaiveDate {
2009 NaiveDate::from_ymd_opt(1999, 7, 14).unwrap()
2010 }
2011
2012 #[test]
2013 fn date() {
2014 let date = test_date();
2015
2016 let bolt = BoltDate::from(date);
2017 let bolt = BoltType::Date(bolt);
2018
2019 let actual = bolt.to::<NaiveDate>().unwrap();
2020 assert_eq!(actual, date);
2021 }
2022
2023 fn test_time() -> NaiveTime {
2024 NaiveTime::from_hms_nano_opt(13, 37, 42, 421337420).unwrap()
2025 }
2026
2027 #[test]
2028 fn local_time() {
2029 let time = test_time();
2030
2031 let bolt = BoltLocalTime::from(time);
2032 let bolt = BoltType::LocalTime(bolt);
2033
2034 let actual = bolt.to::<NaiveTime>().unwrap();
2035 assert_eq!(actual, time);
2036 }
2037
2038 #[test]
2039 fn local_time_optional_offset() {
2040 let time = test_time();
2041
2042 let bolt = BoltLocalTime::from(time);
2043 let bolt = BoltType::LocalTime(bolt);
2044
2045 let acutal = bolt.to::<(NaiveTime, Option<Offset>)>().unwrap();
2046 assert_eq!(acutal.0, time);
2047 assert_eq!(acutal.1, None);
2048 }
2049
2050 #[test]
2051 fn time() {
2052 let time = test_time();
2053
2054 let bolt = BoltTime::from((time, FixedOffset::east_opt(2 * 3600).unwrap()));
2055 let bolt = BoltType::Time(bolt);
2056
2057 let actual = bolt.to::<NaiveTime>().unwrap();
2058 assert_eq!(actual, time);
2059 }
2060
2061 #[test]
2062 fn time_offset() {
2063 let time = test_time();
2064
2065 let bolt = BoltTime::from((time, FixedOffset::east_opt(2 * 3600).unwrap()));
2066 let bolt = BoltType::Time(bolt);
2067
2068 let actual = bolt.to::<(NaiveTime, Offset)>().unwrap();
2069 assert_eq!(actual.0, time);
2070 assert_eq!(actual.1 .0, FixedOffset::east_opt(2 * 3600).unwrap());
2071 }
2072
2073 #[test]
2074 fn time_optional_offset() {
2075 let time = test_time();
2076
2077 let bolt = BoltTime::from((time, FixedOffset::east_opt(2 * 3600).unwrap()));
2078 let bolt = BoltType::Time(bolt);
2079
2080 let actual = bolt.to::<(NaiveTime, Option<Offset>)>().unwrap();
2081 assert_eq!(actual.0, time);
2082 assert_eq!(
2083 actual.1,
2084 Some(Offset(FixedOffset::east_opt(2 * 3600).unwrap()))
2085 );
2086 }
2087
2088 #[test]
2089 fn type_convert() {
2090 let i = BoltType::from(42);
2091
2092 assert_eq!(i.to::<i8>().unwrap(), 42);
2093 }
2094
2095 #[test]
2096 fn type_convert_error() {
2097 let i = BoltType::from(1337);
2098
2099 assert_eq!(
2100 i.to::<i8>().unwrap_err().to_string(),
2101 "Could not convert the integer `1337` to the target type i8"
2102 );
2103 }
2104
2105 #[test]
2106 fn deserialize_roundtrips() {
2107 let map = [
2108 ("age".into(), 42.into()),
2109 ("awesome".into(), true.into()),
2110 ("values".into(), vec![13.37, 42.84].into()),
2111 ("payload".into(), b"Hello, World!".as_slice().into()),
2112 ("secret".into(), BoltType::Null(BoltNull)),
2113 ("event".into(), test_datetime().into()),
2114 ("local_event".into(), test_local_datetime().into()),
2115 ("tz_event".into(), test_datetime_tz().into()),
2116 ("date_event".into(), test_date().into()),
2117 ("local_time_event".into(), test_time().into()),
2118 (
2119 "time_event".into(),
2120 (test_time(), FixedOffset::east_opt(2 * 3600).unwrap()).into(),
2121 ),
2122 ]
2123 .into_iter()
2124 .collect::<BoltMap>();
2125
2126 let map = BoltType::Map(map);
2127
2128 let actual = map.to::<BoltType>().unwrap();
2129 assert_eq!(actual, map);
2130 }
2131
2132 #[test]
2133 fn issue_108_example() {
2134 #[derive(Debug, Deserialize, PartialEq)]
2135 struct Model {
2136 node: Node,
2137 d_left: Option<Node>,
2138 d_right: Option<Node>,
2139 }
2140
2141 #[derive(Deserialize)]
2142 struct Res {
2143 res: Vec<Model>,
2144 }
2145
2146 let model1 = BoltNode::new(BoltInteger::new(1), BoltList::new(), BoltMap::new());
2147 let model2 = BoltNode::new(BoltInteger::new(2), BoltList::new(), BoltMap::new());
2148 let models = HashMap::from_iter([("node", model1), ("d_left", model2)]);
2149 let models = BoltList::from(vec![models.into()]);
2150
2151 let row = Row::new(
2152 vec!["res".into()].into(),
2153 vec![BoltType::List(models)].into(),
2154 );
2155
2156 let m1 = row.get::<Vec<Model>>("res").unwrap();
2157 let m2 = row.to::<Res>().unwrap().res;
2158
2159 assert_eq!(m1, m2);
2160 assert_eq!(m1.len(), 1);
2161
2162 let m = &m1[0];
2163
2164 assert_eq!(m.node.id(), 1);
2165 assert_eq!(m.d_left.as_ref().unwrap().id(), 2);
2166 assert_eq!(m.d_right.as_ref(), None);
2167 }
2168
2169 #[test]
2170 fn deserialize_socket_addr() {
2171 #[derive(Debug, Deserialize)]
2172 struct Test {
2173 addr: SocketAddr,
2174 }
2175
2176 let value = BoltType::from("127.0.0.1:4242");
2177 let value = [(BoltString::from("addr"), value)]
2178 .into_iter()
2179 .collect::<BoltMap>();
2180 let value = BoltType::Map(value);
2181
2182 let actual = value.to::<Test>().unwrap();
2183
2184 assert_eq!(actual.addr, SocketAddr::from(([127, 0, 0, 1], 4242)));
2185 }
2186
2187 #[test]
2188 fn deserialize_some_c_style_enum() {
2189 #[derive(Debug, Copy, Clone, Deserialize, PartialEq, Eq)]
2190 enum Frobnicate {
2191 Foo,
2192 Moo,
2193 Bing,
2194 }
2195
2196 let value = BoltType::from("Foo");
2197
2198 let actual = value.to::<Frobnicate>().unwrap();
2199
2200 assert_eq!(actual, Frobnicate::Foo);
2201 }
2202
2203 #[test]
2204 fn deserialize_tuple_struct() {
2205 #[derive(Deserialize, Debug)]
2206 pub struct MyString(String);
2207
2208 #[derive(Deserialize, Debug)]
2209 pub struct MyThing {
2210 my_string: MyString,
2211 }
2212
2213 let value = BoltType::from("Frobnicate");
2214 let value = [(BoltString::from("my_string"), value)]
2215 .into_iter()
2216 .collect::<BoltMap>();
2217 let value = BoltType::Map(value);
2218
2219 let actual = value.to::<MyThing>().unwrap();
2220
2221 assert_eq!(actual.my_string.0, "Frobnicate");
2222 }
2223
2224 #[test]
2225 fn deserialize_into_serde_json() {
2226 let actual = [
2227 ("age".into(), 42.into()),
2228 ("awesome".into(), true.into()),
2229 ("values".into(), vec![13.37, 42.84].into()),
2230 (
2231 "nested".into(),
2232 BoltType::Map([("key".into(), "value".into())].into_iter().collect()),
2233 ),
2234 ("payload".into(), b"Hello, World!".as_slice().into()),
2235 ("secret".into(), BoltType::Null(BoltNull)),
2236 ]
2237 .into_iter()
2238 .collect::<BoltMap>();
2239
2240 let actual = BoltType::Map(actual);
2241 let actual = actual.to::<serde_json::Value>().unwrap();
2242
2243 let expected = serde_json::json!({
2244 "age": 42,
2245 "awesome": true,
2246 "values": [13.37, 42.84],
2247 "nested": {
2248 "key": "value",
2249 },
2250 "payload": [72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33],
2251 "secret": null,
2252 });
2253
2254 assert_eq!(actual, expected);
2255 }
2256}