Wrote more tests for the Serializer.

crates/node/Cargo.lock

@@ -1,5 +1,7 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
+version = 3
+
 [[package]]
 name = "node"
 version = "0.1.0"
@@ -7,8 +9,57 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "proc-macro2"
+version = "1.0.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "864d3e96a899863136fc6e99f3d7cae289dafe43bf2c5ac19b70df7210c0a145"
+dependencies = [
+ "proc-macro2",
+]
+
 [[package]]
 name = "serde"
 version = "1.0.136"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ce31e24b01e1e524df96f1c2fdd054405f8d7376249a5110886fb4b658484789"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.136"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08597e7152fcd306f41838ed3e37be9eaeed2b61c42e2117266a554fab4662f9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"

crates/node/Cargo.toml

@@ -7,4 +7,4 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-serde = "1.0.136"
+serde = { version = "1.0.136", features = ["derive"] }

crates/node/src/serde_blocktree/ser.rs

@@ -373,6 +373,7 @@ mod test {
         Signature,
         EnvelopedKey
     };
+    use serde::Serialize;
 
     #[test]
     fn serialize_bool() -> Result<()> {
@@ -533,4 +534,108 @@ mod test {
         assert_eq!(vec![10, 0, 0, 0, 118, 97, 112, 105, 100, 32, 240, 159, 152, 145], buffer);
         Ok(())
     }
+
+    #[test]
+    fn serialize_none() -> Result<()> {
+        let none: Option<i32> = Option::None;
+        let buffer = super::to_vec(&none)?;
+        assert_eq!(vec![0], buffer);
+        Ok(())
+    }
+
+    #[test]
+    fn serialize_some() -> Result<()> {
+        // Sometimes I use decimal sometimes I use hex. So what, what to fight about it?
+        let some: Option<i32> = Option::Some(0x02D8);
+        let buffer = super::to_vec(&some)?;
+        assert_eq!(vec![0xD8, 0x02, 0x00, 0x00], buffer);
+        Ok(())
+    }
+
+    #[test]
+    fn serialize_unit() -> Result<()> {
+        let buffer = super::to_vec(&())?;
+        let expected: Vec<u8> = Vec::new();
+        assert_eq!(expected, buffer);
+        Ok(())
+    }
+
+    #[test]
+    fn serialize_unit_struct() -> Result<()> {
+        #[derive(Serialize)]
+        struct UnitStruct;
+
+        let test = UnitStruct {};
+        let buffer = super::to_vec(&test)?;
+        let expected: Vec<u8> = Vec::new();
+        assert_eq!(expected, buffer);
+        Ok(())
+    }
+
+    #[test]
+    fn serialize_unit_struct_variant() -> Result<()> {
+        #[derive(Serialize)]
+        enum UnitStructVariant {
+            Zeroth {},
+            First {},
+            Second {},
+            Third {}
+        }
+        let test = UnitStructVariant::Second {};
+        let buffer = super::to_vec(&test)?;
+        assert_eq!(vec![2, 0, 0, 0], buffer);
+        Ok(())
+    }
+
+    #[test]
+    fn serialize_newtype_struct() -> Result<()> {
+        #[derive(Serialize)]
+        struct Score(u16);
+        let score = Score(512);
+        let buffer = super::to_vec(&score)?;
+        assert_eq!(vec![0x00, 0x02], buffer);
+        Ok(())
+    }
+
+    #[test]
+    fn serialize_newtype_variant() -> Result<()> {
+        #[derive(Serialize)]
+        enum Currency {
+            Usd(i32),
+            Btc(i32),
+            Fil(i32),
+            Eth(i32)
+        }
+        let value = Currency::Fil(1024);
+        let buffer = super::to_vec(&value)?;
+        let expected = vec![
+            0x02, 0x00, 0x00, 0x00, // The variant index.
+            0x00, 0x04, 0x00, 0x00  // The value contained within.
+        ];
+        assert_eq!(expected, buffer);
+        Ok(())
+    }
+
+    #[test]
+    fn serialize_tuple() -> Result<()> {
+        let value = (5u16, -1i8);
+        let buffer = super::to_vec(&value)?;
+        assert_eq!(vec![0x05, 0x00, 0xFF], buffer);
+        Ok(())
+    }
+
+    #[test]
+    fn serialize_tuple_struct() -> Result<()> {
+        #[derive(Serialize)]
+        struct Contrived(i8, String);
+        let value = Contrived(-2, "-2".to_string());
+        let buffer = super::to_vec(&value)?;
+        let expected = vec![
+            0xFE, // The value -2.
+            0x02, 0x00, 0x00, 0x00, // The length of the string.
+            0x2D, 0x32 // The characters '-' and '2'.
+        ];
+        assert_eq!(expected, buffer);
+        Ok(())
+    }
 }