RUST-305 Fix deserialization of non-generic binary (#147)

Author: saghm

src/decoder/serde.rs

@@ -311,7 +311,12 @@ impl<'de> Deserializer<'de> for Decoder {
             Bson::Null => visitor.visit_unit(),
             Bson::I32(v) => visitor.visit_i32(v),
             Bson::I64(v) => visitor.visit_i64(v),
-            Bson::Binary(_, v) => visitor.visit_bytes(&v),
+            Bson::Binary(BinarySubtype::Generic, v) => visitor.visit_bytes(&v),
+            binary @ Bson::Binary(..) => visitor.visit_map(MapDecoder {
+                iter: binary.to_extended_document().into_iter(),
+                value: None,
+                len: 2,
+            }),
             _ => {
                 let doc = value.to_extended_document();
                 let len = doc.len();

src/encoder/serde.rs

@@ -17,6 +17,7 @@ use crate::decimal128::Decimal128;
 use crate::{
     bson::{Array, Bson, Document, TimeStamp, UtcDateTime},
     oid::ObjectId,
+    spec::BinarySubtype,
 };
 
 use super::{to_bson, EncoderError, EncoderResult};
@@ -62,7 +63,7 @@ impl Serialize for Bson {
             Bson::Null => serializer.serialize_unit(),
             Bson::I32(v) => serializer.serialize_i32(v),
             Bson::I64(v) => serializer.serialize_i64(v),
-            Bson::Binary(_, ref v) => serializer.serialize_bytes(v),
+            Bson::Binary(BinarySubtype::Generic, ref v) => serializer.serialize_bytes(v),
             _ => {
                 let doc = self.to_extended_document();
                 doc.serialize(serializer)
@@ -181,7 +182,6 @@ impl Serializer for Encoder {
     }
 
     fn serialize_bytes(self, value: &[u8]) -> EncoderResult<Bson> {
-        use crate::spec::BinarySubtype;
         // let mut state = self.serialize_seq(Some(value.len()))?;
         // for byte in value {
         //     state.serialize_element(byte)?;

tests/serde.rs

@@ -1,6 +1,6 @@
 #![allow(clippy::blacklisted_name)]
 
-use bson::{bson, doc, Bson, Decoder, Encoder};
+use bson::{bson, doc, spec::BinarySubtype, Bson, Decoder, Encoder};
 use serde::{Deserialize, Serialize};
 use serde_derive::{Deserialize, Serialize};
 
@@ -140,6 +140,48 @@ fn test_compat_u2f() {
     assert_eq!(de_foo, foo);
 }
 
+#[test]
+fn test_binary_generic_roundtrip() {
+    #[derive(Serialize, Deserialize, Debug, PartialEq)]
+    pub struct Foo {
+        data: Bson,
+    }
+
+    let x = Foo {
+        data: Bson::Binary(BinarySubtype::Generic, b"12345abcde".to_vec()),
+    };
+
+    let b = bson::to_bson(&x).unwrap();
+    assert_eq!(
+        b.as_document().unwrap(),
+        &doc! {"data": Bson::Binary(BinarySubtype::Generic, b"12345abcde".to_vec())}
+    );
+
+    let f = bson::from_bson::<Foo>(b).unwrap();
+    assert_eq!(x, f);
+}
+
+#[test]
+fn test_binary_non_generic_roundtrip() {
+    #[derive(Serialize, Deserialize, Debug, PartialEq)]
+    pub struct Foo {
+        data: Bson,
+    }
+
+    let x = Foo {
+        data: Bson::Binary(BinarySubtype::BinaryOld, b"12345abcde".to_vec()),
+    };
+
+    let b = bson::to_bson(&x).unwrap();
+    assert_eq!(
+        b.as_document().unwrap(),
+        &doc! {"data": Bson::Binary(BinarySubtype::BinaryOld, b"12345abcde".to_vec())}
+    );
+
+    let f = bson::from_bson::<Foo>(b).unwrap();
+    assert_eq!(x, f);
+}
+
 #[test]
 fn test_byte_vec() {
     #[derive(Serialize, Debug, Eq, PartialEq)]