Added a test for struct deserialization.

crates/node/src/serde_blocktree/de.rs

@@ -73,9 +73,9 @@ impl<'de, T: Read + ?Sized> Deserializer<'de, T> {
     }
 
     fn read_vec(&mut self) -> Result<Vec<u8>> {
-        let len = self.read_u32()?;
-        let mut vec = Vec::with_capacity(try_from(len)?);
-        self.read_exact(&mut vec)?;
+        let len = try_from(self.read_u32()?)?;
+        let mut vec = vec![0; len];
+        self.read_exact(vec.as_mut_slice())?;
         Ok(vec)
     }
 
@@ -226,9 +226,9 @@ impl<'de, 'a, T: Read> de::Deserializer<'de> for &'a mut Deserializer<'de, T> {
     }
 
     fn deserialize_struct<V: Visitor<'de>>(
-        self, _name: &'static str, _fields: &'static [&'static str], visitor: V
+        self, _name: &'static str, fields: &'static [&'static str], visitor: V
     ) -> Result<V::Value> {
-        visitor.visit_newtype_struct(self)
+        self.deserialize_tuple(fields.len(), visitor)
     }
 
     fn deserialize_enum<V: Visitor<'de>>(
@@ -334,6 +334,32 @@ mod test {
         Ok(())
     }
 
+    #[test]
+    fn deserialize_struct() -> Result<()> {
+        #[derive(Debug, PartialEq, Deserialize)]
+        struct Order {
+            customer: String,
+            item_id: u16,
+            quantity: u8
+        }
+        let expected = Order {
+            customer: "Bob".to_string(),
+            item_id: 256,
+            quantity: 255
+        };
+        let vec: Vec<u8> = vec![
+            0x03, 0x00, 0x00, 0x00, 'B' as u8, 'o' as u8, 'b' as u8,
+            0x00, 0x01,
+            0xFF 
+        ];
+        let mut slice = vec.as_slice();
+        let mut de = Deserializer::new(&mut slice);
+        let result = Deserialize::deserialize(&mut de);
+        let actual = result?;
+        assert_eq!(expected, actual);
+        Ok(())
+    }
+
     #[test]
     fn deserialize_enum() -> Result<()> {
         #[derive(Debug, PartialEq, Deserialize)]

crates/node/src/serde_blocktree/ser.rs

@@ -220,7 +220,7 @@ impl<'a, T: Write> ser::Serializer for &'a mut Serializer<T> {
         Ok(self)
     }
 
-    /// A tuples length is not stored, only its entries.
+    /// A tuple's length is not stored, only its entries.
     fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
         Ok(self)
     }