1use crate::{
2 Builder, ByteSource, CryptoError, HasBuilder, HasByteSource, HasIndex, StorableType,
3 TypeBuilder, TypeBuilderContainer,
4};
5use mongodb::bson::{self, Document};
6use serde::{Deserialize, Serialize};
7use std::{convert::TryFrom, fmt::Display, str::FromStr};
8use strum::EnumIter;
9
10#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, EnumIter)]
11pub enum BinaryType {
12 ImageJPEG,
13 ImagePNG,
14 ImageGIF,
15 ImageAPNG,
16 ImageAVIF,
17 ImageSVG,
18 ImageWEBP,
19 VideoMP4,
20 VideoMPEG,
21}
22
23impl TryFrom<&str> for BinaryType {
24 type Error = CryptoError;
25
26 fn try_from(s: &str) -> Result<BinaryType, CryptoError> {
27 match s {
28 "image/jpeg" => Ok(BinaryType::ImageJPEG),
29 "image/png" => Ok(BinaryType::ImagePNG),
30 "image/gif" => Ok(BinaryType::ImageGIF),
31 "image/apng" => Ok(BinaryType::ImageAPNG),
32 "image/avif" => Ok(BinaryType::ImageAVIF),
33 "image/svg+xml" => Ok(BinaryType::ImageSVG),
34 "image/webp" => Ok(BinaryType::ImageWEBP),
35 "video/mp4" => Ok(BinaryType::VideoMP4),
36 "video/mpeg" => Ok(BinaryType::VideoMPEG),
37 _ => Err(CryptoError::NotDeserializableToBaseDataType),
38 }
39 }
40}
41
42impl Display for BinaryType {
43 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
44 write!(
45 f,
46 "{}",
47 match self {
48 BinaryType::ImageJPEG => "image/jpeg",
49 BinaryType::ImagePNG => "image/png",
50 BinaryType::ImageGIF => "image/gif",
51 BinaryType::ImageAPNG => "image/apng",
52 BinaryType::ImageAVIF => "image/avif",
53 BinaryType::ImageSVG => "image/svg+xml",
54 BinaryType::ImageWEBP => "image/webp",
55 BinaryType::VideoMP4 => "video/mp4",
56 BinaryType::VideoMPEG => "video/mpeg",
57 }
58 )
59 }
60}
61
62#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
63pub struct BinaryData {
64 pub binary: String,
65 pub binary_type: BinaryType,
66}
67
68#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
69pub enum Data {
70 Bool(bool),
71 U64(u64),
72 I64(i64),
73 F64(f64),
74 String(String),
75 Binary(Option<BinaryData>),
76}
77
78impl StorableType for Data {}
79
80impl Display for Data {
81 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
82 write!(
83 f,
84 "{}",
85 match self {
86 Data::Bool(b) => b.to_string(),
87 Data::U64(n) => n.to_string(),
88 Data::I64(n) => n.to_string(),
89 Data::F64(n) => n.to_string(),
90 Data::String(s) => s.to_owned(),
91 Data::Binary(b) => {
92 if let Some(b) = b {
93 serde_json::to_string(b).map_err(|_| std::fmt::Error)?
94 } else {
95 "".to_owned()
96 }
97 }
98 }
99 )
100 }
101}
102
103impl From<Data> for ByteSource {
104 fn from(d: Data) -> ByteSource {
105 d.to_string().as_str().into()
106 }
107}
108
109impl HasIndex for Data {
110 type Index = Document;
111
112 fn get_index() -> Option<Self::Index> {
113 Some(bson::doc! {
114 "c": {
115 "builder": {
116 "t": "Data",
117 }
118 }
119 })
120 }
121}
122
123impl HasBuilder for Data {
124 type Builder = DataBuilder;
125
126 fn builder(&self) -> Self::Builder {
127 match self {
128 Self::Bool(_) => DataBuilder::Bool(BoolDataBuilder {}),
129 Self::U64(_) => DataBuilder::U64(U64DataBuilder {}),
130 Self::I64(_) => DataBuilder::I64(I64DataBuilder {}),
131 Self::F64(_) => DataBuilder::F64(F64DataBuilder {}),
132 Self::String(_) => DataBuilder::String(StringDataBuilder {}),
133 Self::Binary(_) => DataBuilder::Binary(BinaryDataBuilder {}),
134 }
135 }
136}
137
138impl HasByteSource for Data {
139 fn byte_source(&self) -> ByteSource {
140 self.clone().into()
141 }
142}
143
144#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
145#[serde(tag = "t", content = "c")]
146pub enum DataBuilder {
147 Bool(BoolDataBuilder),
148 U64(U64DataBuilder),
149 I64(I64DataBuilder),
150 F64(F64DataBuilder),
151 String(StringDataBuilder),
152 Binary(BinaryDataBuilder),
153}
154
155impl TryFrom<TypeBuilderContainer> for DataBuilder {
156 type Error = CryptoError;
157
158 fn try_from(builder: TypeBuilderContainer) -> Result<Self, Self::Error> {
159 match builder.0 {
160 TypeBuilder::Data(db) => Ok(db),
161 _ => Err(CryptoError::NotDowncastable),
162 }
163 }
164}
165
166impl From<DataBuilder> for TypeBuilder {
167 fn from(db: DataBuilder) -> TypeBuilder {
168 TypeBuilder::Data(db)
169 }
170}
171
172impl Builder for DataBuilder {
173 type Output = Data;
174
175 fn build(&self, bytes: Option<&[u8]>) -> Result<Self::Output, CryptoError> {
176 match self {
177 Self::Bool(bdb) => bdb.build(bytes),
178 Self::U64(ndb) => ndb.build(bytes),
179 Self::I64(ndb) => ndb.build(bytes),
180 Self::F64(ndb) => ndb.build(bytes),
181 Self::String(sdb) => sdb.build(bytes),
182 Self::Binary(bdb) => bdb.build(bytes),
183 }
184 }
185}
186
187#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
188pub struct BoolDataBuilder {}
189
190impl TryFrom<TypeBuilderContainer> for BoolDataBuilder {
191 type Error = CryptoError;
192
193 fn try_from(builder: TypeBuilderContainer) -> Result<Self, Self::Error> {
194 match builder.0 {
195 TypeBuilder::Data(DataBuilder::Bool(bdb)) => Ok(bdb),
196 _ => Err(CryptoError::NotDowncastable),
197 }
198 }
199}
200
201impl From<BoolDataBuilder> for TypeBuilder {
202 fn from(bdb: BoolDataBuilder) -> TypeBuilder {
203 TypeBuilder::Data(DataBuilder::Bool(bdb))
204 }
205}
206
207impl Builder for BoolDataBuilder {
208 type Output = Data;
209
210 fn build(&self, bytes: Option<&[u8]>) -> Result<Self::Output, CryptoError> {
211 match bytes {
212 Some(bytes) => {
213 let s = String::from_utf8(bytes.to_vec())
214 .map_err(|_| CryptoError::NotDeserializableToBaseDataType)?;
215 let b =
216 bool::from_str(&s).map_err(|_| CryptoError::NotDeserializableToBaseDataType)?;
217 Ok(Data::Bool(b))
218 }
219 None => Ok(Data::Bool(false)),
220 }
221 }
222}
223
224#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
225pub struct U64DataBuilder {}
226
227impl TryFrom<TypeBuilderContainer> for U64DataBuilder {
228 type Error = CryptoError;
229
230 fn try_from(builder: TypeBuilderContainer) -> Result<Self, Self::Error> {
231 match builder.0 {
232 TypeBuilder::Data(DataBuilder::U64(ndb)) => Ok(ndb),
233 _ => Err(CryptoError::NotDowncastable),
234 }
235 }
236}
237
238impl From<U64DataBuilder> for TypeBuilder {
239 fn from(ndb: U64DataBuilder) -> TypeBuilder {
240 TypeBuilder::Data(DataBuilder::U64(ndb))
241 }
242}
243
244impl Builder for U64DataBuilder {
245 type Output = Data;
246
247 fn build(&self, bytes: Option<&[u8]>) -> Result<Self::Output, CryptoError> {
248 match bytes {
249 Some(bytes) => {
250 let s = String::from_utf8(bytes.to_vec())
251 .map_err(|_| CryptoError::NotDeserializableToBaseDataType)?;
252 let n =
253 u64::from_str(&s).map_err(|_| CryptoError::NotDeserializableToBaseDataType)?;
254 Ok(Data::U64(n))
255 }
256 None => Ok(Data::U64(0)),
257 }
258 }
259}
260
261#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
262pub struct I64DataBuilder {}
263
264impl TryFrom<TypeBuilderContainer> for I64DataBuilder {
265 type Error = CryptoError;
266
267 fn try_from(builder: TypeBuilderContainer) -> Result<Self, Self::Error> {
268 match builder.0 {
269 TypeBuilder::Data(DataBuilder::I64(ndb)) => Ok(ndb),
270 _ => Err(CryptoError::NotDowncastable),
271 }
272 }
273}
274
275impl From<I64DataBuilder> for TypeBuilder {
276 fn from(ndb: I64DataBuilder) -> TypeBuilder {
277 TypeBuilder::Data(DataBuilder::I64(ndb))
278 }
279}
280
281impl Builder for I64DataBuilder {
282 type Output = Data;
283
284 fn build(&self, bytes: Option<&[u8]>) -> Result<Self::Output, CryptoError> {
285 match bytes {
286 Some(bytes) => {
287 let s = String::from_utf8(bytes.to_vec())
288 .map_err(|_| CryptoError::NotDeserializableToBaseDataType)?;
289 let n =
290 i64::from_str(&s).map_err(|_| CryptoError::NotDeserializableToBaseDataType)?;
291 Ok(Data::I64(n))
292 }
293 None => Ok(Data::I64(0)),
294 }
295 }
296}
297
298#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
299pub struct F64DataBuilder {}
300
301impl TryFrom<TypeBuilderContainer> for F64DataBuilder {
302 type Error = CryptoError;
303
304 fn try_from(builder: TypeBuilderContainer) -> Result<Self, Self::Error> {
305 match builder.0 {
306 TypeBuilder::Data(DataBuilder::F64(ndb)) => Ok(ndb),
307 _ => Err(CryptoError::NotDowncastable),
308 }
309 }
310}
311
312impl From<F64DataBuilder> for TypeBuilder {
313 fn from(ndb: F64DataBuilder) -> TypeBuilder {
314 TypeBuilder::Data(DataBuilder::F64(ndb))
315 }
316}
317
318impl Builder for F64DataBuilder {
319 type Output = Data;
320
321 fn build(&self, bytes: Option<&[u8]>) -> Result<Self::Output, CryptoError> {
322 match bytes {
323 Some(bytes) => {
324 let s = String::from_utf8(bytes.to_vec())
325 .map_err(|_| CryptoError::NotDeserializableToBaseDataType)?;
326 let n =
327 f64::from_str(&s).map_err(|_| CryptoError::NotDeserializableToBaseDataType)?;
328 Ok(Data::F64(n))
329 }
330 None => Ok(Data::F64(0.0)),
331 }
332 }
333}
334
335#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
336pub struct StringDataBuilder {}
337
338impl TryFrom<TypeBuilderContainer> for StringDataBuilder {
339 type Error = CryptoError;
340
341 fn try_from(builder: TypeBuilderContainer) -> Result<Self, Self::Error> {
342 match builder.0 {
343 TypeBuilder::Data(DataBuilder::String(sdb)) => Ok(sdb),
344 _ => Err(CryptoError::NotDowncastable),
345 }
346 }
347}
348
349impl From<StringDataBuilder> for TypeBuilder {
350 fn from(sdb: StringDataBuilder) -> TypeBuilder {
351 TypeBuilder::Data(DataBuilder::String(sdb))
352 }
353}
354
355impl Builder for StringDataBuilder {
356 type Output = Data;
357
358 fn build(&self, bytes: Option<&[u8]>) -> Result<Self::Output, CryptoError> {
359 match bytes {
360 Some(bytes) => {
361 let s = String::from_utf8(bytes.to_vec())
362 .map_err(|_| CryptoError::NotDeserializableToBaseDataType)?;
363 Ok(Data::String(s))
364 }
365 None => Ok(Data::String("".to_owned())),
366 }
367 }
368}
369
370#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
371pub struct BinaryDataBuilder {}
372
373impl TryFrom<TypeBuilderContainer> for BinaryDataBuilder {
374 type Error = CryptoError;
375
376 fn try_from(builder: TypeBuilderContainer) -> Result<Self, Self::Error> {
377 match builder.0 {
378 TypeBuilder::Data(DataBuilder::Binary(bdb)) => Ok(bdb),
379 _ => Err(CryptoError::NotDowncastable),
380 }
381 }
382}
383
384impl From<BinaryDataBuilder> for TypeBuilder {
385 fn from(bdb: BinaryDataBuilder) -> TypeBuilder {
386 TypeBuilder::Data(DataBuilder::Binary(bdb))
387 }
388}
389
390impl Builder for BinaryDataBuilder {
391 type Output = Data;
392
393 fn build(&self, data: Option<&[u8]>) -> Result<Self::Output, CryptoError> {
394 match data {
395 Some(binary_data_bytes) => {
396 let s = String::from_utf8(binary_data_bytes.to_vec())
397 .map_err(|_| CryptoError::NotDeserializableToBaseDataType)?;
398 let bd: BinaryData = serde_json::from_str(&s)
399 .map_err(|_| CryptoError::NotDeserializableToBaseDataType)?;
400 Ok(Data::Binary(Some(bd)))
401 }
402 None => Ok(Data::String("".to_owned())),
403 }
404 }
405}
406
407#[cfg(test)]
408mod tests {
409 use super::{
410 BinaryDataBuilder, BoolDataBuilder, Data, DataBuilder, F64DataBuilder, I64DataBuilder,
411 StringDataBuilder, U64DataBuilder,
412 };
413 use crate::{
414 key::sodiumoxide::SodiumOxideSymmetricKeyBuilder, BinaryData, BinaryType, Builder,
415 ByteSource, HasBuilder, HasIndex, KeyBuilder, SymmetricKeyBuilder, TypeBuilder,
416 TypeBuilderContainer,
417 };
418 use mongodb::bson::{self, Document};
419 use std::convert::{Into, TryInto};
420
421 #[test]
422 fn test_display_bool_data() {
423 let d_true = Data::Bool(true);
424 let d_false = Data::Bool(false);
425
426 assert_eq!(d_true.to_string(), "true");
427 assert_eq!(d_false.to_string(), "false");
428 }
429
430 #[test]
431 fn test_display_u64_data() {
432 let d = Data::U64(10);
433
434 assert_eq!(d.to_string(), "10");
435 }
436
437 #[test]
438 fn test_display_i64_data() {
439 let d = Data::I64(-10);
440
441 assert_eq!(d.to_string(), "-10");
442 }
443
444 #[test]
445 fn test_display_f64_data() {
446 let d = Data::F64(10.53);
447
448 assert_eq!(d.to_string(), "10.53");
449 }
450
451 #[test]
452 fn test_display_string_data() {
453 let d = Data::String("hello, world!".to_owned());
454
455 assert_eq!(d.to_string(), "hello, world!");
456 }
457
458 #[test]
459 fn test_display_binary_jpeg_data() {
460 let binary_data = BinaryData {
461 binary: "abc".to_string(),
462 binary_type: BinaryType::ImageJPEG,
463 };
464 let d = Data::Binary(Some(binary_data));
465 assert_eq!(
466 d.to_string(),
467 "{\"binary\":\"abc\",\"binary_type\":\"ImageJPEG\"}"
468 );
469 }
470
471 #[test]
472 fn test_display_binary_png_data() {
473 let binary_data = BinaryData {
474 binary: "abc".to_string(),
475 binary_type: BinaryType::ImagePNG,
476 };
477 let d = Data::Binary(Some(binary_data));
478 assert_eq!(
479 d.to_string(),
480 "{\"binary\":\"abc\",\"binary_type\":\"ImagePNG\"}"
481 );
482 }
483
484 #[test]
485 fn test_display_binary_gif_data() {
486 let binary_data = BinaryData {
487 binary: "abc".to_string(),
488 binary_type: BinaryType::ImageGIF,
489 };
490 let d = Data::Binary(Some(binary_data));
491 assert_eq!(
492 d.to_string(),
493 "{\"binary\":\"abc\",\"binary_type\":\"ImageGIF\"}"
494 );
495 }
496
497 #[test]
498 fn test_display_binary_apng_data() {
499 let binary_data = BinaryData {
500 binary: "abc".to_string(),
501 binary_type: BinaryType::ImageAPNG,
502 };
503 let d = Data::Binary(Some(binary_data));
504 assert_eq!(
505 d.to_string(),
506 "{\"binary\":\"abc\",\"binary_type\":\"ImageAPNG\"}"
507 );
508 }
509
510 #[test]
511 fn test_display_binary_avif_data() {
512 let binary_data = BinaryData {
513 binary: "abc".to_string(),
514 binary_type: BinaryType::ImageAVIF,
515 };
516 let d = Data::Binary(Some(binary_data));
517 assert_eq!(
518 d.to_string(),
519 "{\"binary\":\"abc\",\"binary_type\":\"ImageAVIF\"}"
520 );
521 }
522
523 #[test]
524 fn test_display_binary_svg_data() {
525 let binary_data = BinaryData {
526 binary: "abc".to_string(),
527 binary_type: BinaryType::ImageSVG,
528 };
529 let d = Data::Binary(Some(binary_data));
530 assert_eq!(
531 d.to_string(),
532 "{\"binary\":\"abc\",\"binary_type\":\"ImageSVG\"}"
533 );
534 }
535
536 #[test]
537 fn test_display_binary_webp_data() {
538 let binary_data = BinaryData {
539 binary: "abc".to_string(),
540 binary_type: BinaryType::ImageWEBP,
541 };
542 let d = Data::Binary(Some(binary_data));
543 assert_eq!(
544 d.to_string(),
545 "{\"binary\":\"abc\",\"binary_type\":\"ImageWEBP\"}"
546 );
547 }
548
549 #[test]
550 fn test_display_binary_mp4_data() {
551 let binary_data = BinaryData {
552 binary: "abc".to_string(),
553 binary_type: BinaryType::VideoMP4,
554 };
555 let d = Data::Binary(Some(binary_data));
556 assert_eq!(
557 d.to_string(),
558 "{\"binary\":\"abc\",\"binary_type\":\"VideoMP4\"}"
559 );
560 }
561
562 #[test]
563 fn test_display_binary_mpeg_data() {
564 let binary_data = BinaryData {
565 binary: "abc".to_string(),
566 binary_type: BinaryType::VideoMPEG,
567 };
568 let d = Data::Binary(Some(binary_data));
569 assert_eq!(
570 d.to_string(),
571 "{\"binary\":\"abc\",\"binary_type\":\"VideoMPEG\"}"
572 );
573 }
574
575 #[test]
576 fn test_data_to_bytesource() {
577 let d = Data::String("hello, world!".to_owned());
578 let bs: ByteSource = d.into();
579
580 assert_eq!(
581 String::from_utf8(bs.get().unwrap().to_vec()).unwrap(),
582 "hello, world!".to_owned()
583 );
584 }
585
586 #[test]
587 fn test_data_to_index() {
588 let index: Document = Data::get_index().unwrap();
589
590 assert_eq!(
591 index,
592 bson::doc! {
593 "c": {
594 "builder": {
595 "t": "Data",
596 }
597 }
598 }
599 );
600 }
601
602 #[test]
603 fn test_data_to_builder() {
604 let db = Data::Bool(true);
605 let du = Data::U64(10);
606 let di = Data::I64(-10);
607 let df = Data::F64(-10.46);
608 let ds = Data::String("hello, world!".to_owned());
609
610 let binary_jpeg = BinaryData {
611 binary: "abc".to_string(),
612 binary_type: BinaryType::ImageJPEG,
613 };
614 let d_binary_jpeg = Data::Binary(Some(binary_jpeg));
615
616 let binary_png = BinaryData {
617 binary: "abc".to_string(),
618 binary_type: BinaryType::ImagePNG,
619 };
620 let d_binary_png = Data::Binary(Some(binary_png));
621
622 let binary_gif = BinaryData {
623 binary: "abc".to_string(),
624 binary_type: BinaryType::ImageGIF,
625 };
626 let d_binary_gif = Data::Binary(Some(binary_gif));
627
628 let binary_apng = BinaryData {
629 binary: "abc".to_string(),
630 binary_type: BinaryType::ImageAPNG,
631 };
632 let d_binary_apng = Data::Binary(Some(binary_apng));
633
634 let binary_avif = BinaryData {
635 binary: "abc".to_string(),
636 binary_type: BinaryType::ImageAVIF,
637 };
638 let d_binary_avif = Data::Binary(Some(binary_avif));
639
640 let binary_svg = BinaryData {
641 binary: "abc".to_string(),
642 binary_type: BinaryType::ImageSVG,
643 };
644 let d_binary_svg = Data::Binary(Some(binary_svg));
645
646 let binary_webp = BinaryData {
647 binary: "abc".to_string(),
648 binary_type: BinaryType::ImageWEBP,
649 };
650 let d_binary_webp = Data::Binary(Some(binary_webp));
651
652 let binary_mpeg = BinaryData {
653 binary: "abc".to_string(),
654 binary_type: BinaryType::VideoMPEG,
655 };
656 let d_binary_mpeg = Data::Binary(Some(binary_mpeg));
657
658 let binary_mp4 = BinaryData {
659 binary: "abc".to_string(),
660 binary_type: BinaryType::VideoMP4,
661 };
662 let d_binary_mp4 = Data::Binary(Some(binary_mp4));
663
664 assert_eq!(
665 db.builder().build(Some(b"true")).unwrap().to_string(),
666 db.to_string()
667 );
668 assert_eq!(
669 du.builder().build(Some(b"10")).unwrap().to_string(),
670 du.to_string()
671 );
672 assert_eq!(
673 di.builder().build(Some(b"-10")).unwrap().to_string(),
674 di.to_string()
675 );
676 assert_eq!(
677 df.builder().build(Some(b"-10.46")).unwrap().to_string(),
678 df.to_string()
679 );
680 assert_eq!(
681 ds.builder()
682 .build(Some(b"hello, world!"))
683 .unwrap()
684 .to_string(),
685 ds.to_string()
686 );
687 assert_eq!(
688 d_binary_jpeg
689 .builder()
690 .build(Some(b"{\"binary\":\"abc\",\"binary_type\":\"ImageJPEG\"}"))
691 .unwrap()
692 .to_string(),
693 d_binary_jpeg.to_string()
694 );
695 assert_eq!(
696 d_binary_png
697 .builder()
698 .build(Some(b"{\"binary\":\"abc\",\"binary_type\":\"ImagePNG\"}"))
699 .unwrap()
700 .to_string(),
701 d_binary_png.to_string()
702 );
703 assert_eq!(
704 d_binary_gif
705 .builder()
706 .build(Some(b"{\"binary\":\"abc\",\"binary_type\":\"ImageGIF\"}"))
707 .unwrap()
708 .to_string(),
709 d_binary_gif.to_string()
710 );
711 assert_eq!(
712 d_binary_apng
713 .builder()
714 .build(Some(b"{\"binary\":\"abc\",\"binary_type\":\"ImageAPNG\"}"))
715 .unwrap()
716 .to_string(),
717 d_binary_apng.to_string()
718 );
719 assert_eq!(
720 d_binary_avif
721 .builder()
722 .build(Some(b"{\"binary\":\"abc\",\"binary_type\":\"ImageAVIF\"}"))
723 .unwrap()
724 .to_string(),
725 d_binary_avif.to_string()
726 );
727 assert_eq!(
728 d_binary_svg
729 .builder()
730 .build(Some(b"{\"binary\":\"abc\",\"binary_type\":\"ImageSVG\"}"))
731 .unwrap()
732 .to_string(),
733 d_binary_svg.to_string()
734 );
735 assert_eq!(
736 d_binary_webp
737 .builder()
738 .build(Some(b"{\"binary\":\"abc\",\"binary_type\":\"ImageWEBP\"}"))
739 .unwrap()
740 .to_string(),
741 d_binary_webp.to_string()
742 );
743 assert_eq!(
744 d_binary_mpeg
745 .builder()
746 .build(Some(b"{\"binary\":\"abc\",\"binary_type\":\"VideoMPEG\"}"))
747 .unwrap()
748 .to_string(),
749 d_binary_mpeg.to_string()
750 );
751 assert_eq!(
752 d_binary_mp4
753 .builder()
754 .build(Some(b"{\"binary\":\"abc\",\"binary_type\":\"VideoMP4\"}"))
755 .unwrap()
756 .to_string(),
757 d_binary_mp4.to_string()
758 );
759 }
760
761 #[test]
762 fn test_databuilder_from_typebuildercontainer_valid() {
763 let tbc = TypeBuilderContainer(TypeBuilder::Data(DataBuilder::Bool(BoolDataBuilder {})));
764 let db: DataBuilder = tbc.try_into().unwrap();
765 let d = db.build(Some(b"true")).unwrap();
766 match d {
767 Data::Bool(b) => assert_eq!(b, true),
768 _ => panic!("Extracted data should have been a bool-type"),
769 }
770 }
771
772 #[test]
773 #[should_panic]
774 fn test_databuilder_from_typebuildercontainer_invalid() {
775 let tbc = TypeBuilderContainer(TypeBuilder::Key(KeyBuilder::Symmetric(
776 SymmetricKeyBuilder::SodiumOxide(SodiumOxideSymmetricKeyBuilder {}),
777 )));
778 let _: DataBuilder = tbc.try_into().unwrap();
779 }
780
781 #[test]
782 fn test_booldatabuilder_build_true() {
783 let bdb = BoolDataBuilder {};
784 let d = bdb.build(Some(b"true")).unwrap();
785 match d {
786 Data::Bool(b) => assert_eq!(b, true),
787 _ => panic!("Extracted data should have been a bool-type"),
788 }
789 }
790
791 #[test]
792 fn test_booldatabuilder_build_false() {
793 let bdb = BoolDataBuilder {};
794 let d = bdb.build(Some(b"false")).unwrap();
795 match d {
796 Data::Bool(b) => assert_eq!(b, false),
797 _ => panic!("Extracted data should have been a bool-type"),
798 }
799 }
800
801 #[test]
802 fn test_booldatabuilder_from_typebuildercontainer_valid() {
803 let tbc = TypeBuilderContainer(TypeBuilder::Data(DataBuilder::Bool(BoolDataBuilder {})));
804 let _: BoolDataBuilder = tbc.try_into().unwrap();
805 }
806
807 #[test]
808 #[should_panic]
809 fn test_booldatabuilder_from_typebuildercontainer_invalid() {
810 let tbc = TypeBuilderContainer(TypeBuilder::Key(KeyBuilder::Symmetric(
811 SymmetricKeyBuilder::SodiumOxide(SodiumOxideSymmetricKeyBuilder {}),
812 )));
813 let _: BoolDataBuilder = tbc.try_into().unwrap();
814 }
815
816 #[test]
817 fn test_u64databuilder_build_valid() {
818 let udb = U64DataBuilder {};
819 let d = udb.build(Some(b"10")).unwrap();
820 match d {
821 Data::U64(n) => assert_eq!(n, 10),
822 _ => panic!("Extracted data should have been a u64-type"),
823 }
824 }
825
826 #[test]
827 #[should_panic]
828 fn test_u64databuilder_build_invalid() {
829 let udb = U64DataBuilder {};
830 udb.build(Some(b"-10")).unwrap();
831 }
832
833 #[test]
834 fn test_u64databuilder_from_typebuildercontainer_valid() {
835 let tbc = TypeBuilderContainer(TypeBuilder::Data(DataBuilder::U64(U64DataBuilder {})));
836 let _: U64DataBuilder = tbc.try_into().unwrap();
837 }
838
839 #[test]
840 #[should_panic]
841 fn test_u64databuilder_from_typebuildercontainer_invalid() {
842 let tbc = TypeBuilderContainer(TypeBuilder::Key(KeyBuilder::Symmetric(
843 SymmetricKeyBuilder::SodiumOxide(SodiumOxideSymmetricKeyBuilder {}),
844 )));
845 let _: U64DataBuilder = tbc.try_into().unwrap();
846 }
847
848 #[test]
849 fn test_i64databuilder_build_valid() {
850 let udb = I64DataBuilder {};
851 let d = udb.build(Some(b"-10")).unwrap();
852 match d {
853 Data::I64(n) => assert_eq!(n, -10),
854 _ => panic!("Extracted data should have been a i64-type"),
855 }
856 }
857
858 #[test]
859 #[should_panic]
860 fn test_i64databuilder_build_invalid() {
861 let udb = I64DataBuilder {};
862 udb.build(Some(b"-10.54")).unwrap();
863 }
864
865 #[test]
866 fn test_i64databuilder_from_typebuildercontainer_valid() {
867 let tbc = TypeBuilderContainer(TypeBuilder::Data(DataBuilder::I64(I64DataBuilder {})));
868 let _: I64DataBuilder = tbc.try_into().unwrap();
869 }
870
871 #[test]
872 #[should_panic]
873 fn test_i64databuilder_from_typebuildercontainer_invalid() {
874 let tbc = TypeBuilderContainer(TypeBuilder::Key(KeyBuilder::Symmetric(
875 SymmetricKeyBuilder::SodiumOxide(SodiumOxideSymmetricKeyBuilder {}),
876 )));
877 let _: I64DataBuilder = tbc.try_into().unwrap();
878 }
879
880 #[test]
881 fn test_f64databuilder_build_valid() {
882 let udb = F64DataBuilder {};
883 let d = udb.build(Some(b"-10.53")).unwrap();
884 match d {
885 Data::F64(n) => assert!((n + 10.53).abs() < f64::EPSILON),
886 _ => panic!("Extracted data should have been a f64-type"),
887 }
888 }
889
890 #[test]
891 #[should_panic]
892 fn test_f64databuilder_build_invalid() {
893 let udb = F64DataBuilder {};
894 udb.build(Some(b"somestr")).unwrap();
895 }
896
897 #[test]
898 fn test_f64databuilder_from_typebuildercontainer_valid() {
899 let tbc = TypeBuilderContainer(TypeBuilder::Data(DataBuilder::F64(F64DataBuilder {})));
900 let _: F64DataBuilder = tbc.try_into().unwrap();
901 }
902
903 #[test]
904 #[should_panic]
905 fn test_f64databuilder_from_typebuildercontainer_invalid() {
906 let tbc = TypeBuilderContainer(TypeBuilder::Key(KeyBuilder::Symmetric(
907 SymmetricKeyBuilder::SodiumOxide(SodiumOxideSymmetricKeyBuilder {}),
908 )));
909 let _: F64DataBuilder = tbc.try_into().unwrap();
910 }
911
912 #[test]
913 fn test_stringdatabuilder_build_valid() {
914 let sdb = StringDataBuilder {};
915 let d = sdb.build(Some(b"hello, world!")).unwrap();
916 match d {
917 Data::String(s) => assert_eq!(s, "hello, world!".to_owned()),
918 _ => panic!("Extracted data should have been a string-type"),
919 }
920 }
921
922 #[test]
923 #[should_panic]
924 fn test_stringdatabuilder_build_invalid() {
925 let udb = StringDataBuilder {};
926 udb.build(Some(vec![0xc3, 0x28].as_ref())).unwrap();
927 }
928
929 #[test]
930 fn test_stringdatabuilder_from_typebuildercontainer_valid() {
931 let tbc =
932 TypeBuilderContainer(TypeBuilder::Data(DataBuilder::String(StringDataBuilder {})));
933 let db: StringDataBuilder = tbc.try_into().unwrap();
934 let d = db.build(Some(b"hello, world!")).unwrap();
935 match d {
936 Data::String(s) => assert_eq!(s, "hello, world!".to_owned()),
937 _ => panic!("Extracted data should have been a string-type"),
938 }
939 }
940
941 #[test]
942 #[should_panic]
943 fn test_stringdatabuilder_from_typebuildercontainer_invalid() {
944 let tbc = TypeBuilderContainer(TypeBuilder::Key(KeyBuilder::Symmetric(
945 SymmetricKeyBuilder::SodiumOxide(SodiumOxideSymmetricKeyBuilder {}),
946 )));
947 let _: StringDataBuilder = tbc.try_into().unwrap();
948 }
949
950 #[test]
951 fn test_binarydatabuilder_jpeg_build_valid() {
952 let udb = BinaryDataBuilder {};
953 let d = udb
954 .build(Some(b"{\"binary\":\"abc\",\"binary_type\":\"ImageJPEG\"}"))
955 .unwrap();
956 match d {
957 Data::Binary(b) => match b {
958 Some(bd) => {
959 assert_eq!(bd.binary_type, BinaryType::ImageJPEG);
960 assert_eq!(bd.binary, "abc");
961 }
962 _ => panic!("Extracted data should have been a binary-type"),
963 },
964 _ => panic!("Extracted data should have been a binary-type"),
965 }
966 }
967
968 #[test]
969 fn test_binarydatabuilder_png_build_valid() {
970 let udb = BinaryDataBuilder {};
971 let d = udb
972 .build(Some(b"{\"binary\":\"abc\",\"binary_type\":\"ImagePNG\"}"))
973 .unwrap();
974 match d {
975 Data::Binary(b) => match b {
976 Some(bd) => {
977 assert_eq!(bd.binary_type, BinaryType::ImagePNG);
978 assert_eq!(bd.binary, "abc");
979 }
980 _ => panic!("Extracted data should have been a binary-type"),
981 },
982 _ => panic!("Extracted data should have been a binary"),
983 }
984 }
985
986 #[test]
987 fn test_binarydatabuilder_gif_build_valid() {
988 let udb = BinaryDataBuilder {};
989 let d = udb
990 .build(Some(b"{\"binary\":\"abc\",\"binary_type\":\"ImageGIF\"}"))
991 .unwrap();
992 match d {
993 Data::Binary(b) => match b {
994 Some(bd) => {
995 assert_eq!(bd.binary_type, BinaryType::ImageGIF);
996 assert_eq!(bd.binary, "abc");
997 }
998 _ => panic!("Extracted data should have been a binary-type"),
999 },
1000 _ => panic!("Extracted data should have been a binary"),
1001 }
1002 }
1003
1004 #[test]
1005 fn test_binarydatabuilder_apng_build_valid() {
1006 let udb = BinaryDataBuilder {};
1007 let d = udb
1008 .build(Some(b"{\"binary\":\"abc\",\"binary_type\":\"ImageAPNG\"}"))
1009 .unwrap();
1010 match d {
1011 Data::Binary(b) => match b {
1012 Some(bd) => {
1013 assert_eq!(bd.binary_type, BinaryType::ImageAPNG);
1014 assert_eq!(bd.binary, "abc");
1015 }
1016 _ => panic!("Extracted data should have been a binary-type"),
1017 },
1018 _ => panic!("Extracted data should have been a binary"),
1019 }
1020 }
1021
1022 #[test]
1023 fn test_binarydatabuilder_avif_build_valid() {
1024 let udb = BinaryDataBuilder {};
1025 let d = udb
1026 .build(Some(b"{\"binary\":\"abc\",\"binary_type\":\"ImageAVIF\"}"))
1027 .unwrap();
1028 match d {
1029 Data::Binary(b) => match b {
1030 Some(bd) => {
1031 assert_eq!(bd.binary_type, BinaryType::ImageAVIF);
1032 assert_eq!(bd.binary, "abc");
1033 }
1034 _ => panic!("Extracted data should have been a binary-type"),
1035 },
1036 _ => panic!("Extracted data should have been a binary"),
1037 }
1038 }
1039
1040 #[test]
1041 fn test_binarydatabuilder_svg_build_valid() {
1042 let udb = BinaryDataBuilder {};
1043 let d = udb
1044 .build(Some(b"{\"binary\":\"abc\",\"binary_type\":\"ImageSVG\"}"))
1045 .unwrap();
1046 match d {
1047 Data::Binary(b) => match b {
1048 Some(bd) => {
1049 assert_eq!(bd.binary_type, BinaryType::ImageSVG);
1050 assert_eq!(bd.binary, "abc");
1051 }
1052 _ => panic!("Extracted data should have been a binary-type"),
1053 },
1054 _ => panic!("Extracted data should have been a binary"),
1055 }
1056 }
1057
1058 #[test]
1059 fn test_binarydatabuilder_webp_build_valid() {
1060 let udb = BinaryDataBuilder {};
1061 let d = udb
1062 .build(Some(b"{\"binary\":\"abc\",\"binary_type\":\"ImageWEBP\"}"))
1063 .unwrap();
1064 match d {
1065 Data::Binary(b) => match b {
1066 Some(bd) => {
1067 assert_eq!(bd.binary_type, BinaryType::ImageWEBP);
1068 assert_eq!(bd.binary, "abc");
1069 }
1070 _ => panic!("Extracted data should have been a binary-type"),
1071 },
1072 _ => panic!("Extracted data should have been a binary"),
1073 }
1074 }
1075
1076 #[test]
1077 fn test_binarydatabuilder_mpeg_build_valid() {
1078 let udb = BinaryDataBuilder {};
1079 let d = udb
1080 .build(Some(b"{\"binary\":\"abc\",\"binary_type\":\"VideoMPEG\"}"))
1081 .unwrap();
1082 match d {
1083 Data::Binary(b) => match b {
1084 Some(bd) => {
1085 assert_eq!(bd.binary_type, BinaryType::VideoMPEG);
1086 assert_eq!(bd.binary, "abc");
1087 }
1088 _ => panic!("Extracted data should have been a binary-type"),
1089 },
1090 _ => panic!("Extracted data should have been a binary"),
1091 }
1092 }
1093
1094 #[test]
1095 fn test_binarydatabuilder_mp4_build_valid() {
1096 let udb = BinaryDataBuilder {};
1097 let d = udb
1098 .build(Some(b"{\"binary\":\"abc\",\"binary_type\":\"VideoMP4\"}"))
1099 .unwrap();
1100 match d {
1101 Data::Binary(b) => match b {
1102 Some(bd) => {
1103 assert_eq!(bd.binary_type, BinaryType::VideoMP4);
1104 assert_eq!(bd.binary, "abc");
1105 }
1106 _ => panic!("Extracted data should have been a binary-type"),
1107 },
1108 _ => panic!("Extracted data should have been a binary"),
1109 }
1110 }
1111
1112 #[test]
1113 #[should_panic]
1114 fn test_binarydatabuilder_build_invalid() {
1115 let udb = BinaryDataBuilder {};
1116 udb.build(Some(b"-10")).unwrap();
1117 }
1118
1119 #[test]
1120 #[should_panic]
1121 fn test_binarydatabuilder_build_invalid_binary_type() {
1122 let udb = BinaryDataBuilder {};
1123 udb.build(Some(b"{\"binary\":\"abc\",\"binary_type\":\"ImageXYZ\"}"))
1124 .unwrap();
1125 }
1126
1127 #[test]
1128 fn test_binarydatabuilder_from_typebuildercontainer_valid() {
1129 let tbc =
1130 TypeBuilderContainer(TypeBuilder::Data(DataBuilder::Binary(BinaryDataBuilder {})));
1131 let _: BinaryDataBuilder = tbc.try_into().unwrap();
1132 }
1133
1134 #[test]
1135 #[should_panic]
1136 fn test_binarydatabuilder_from_typebuildercontainer_invalid() {
1137 let tbc = TypeBuilderContainer(TypeBuilder::Key(KeyBuilder::Symmetric(
1138 SymmetricKeyBuilder::SodiumOxide(SodiumOxideSymmetricKeyBuilder {}),
1139 )));
1140 let _: BinaryDataBuilder = tbc.try_into().unwrap();
1141 }
1142}