add unit tests

src/lib.rs

@@ -71,7 +71,7 @@ impl MessageBody {
 ///
 /// This has everything needed to reconstruct a message.
 // FIXME: we should try to replace MessageHeader with MessageHeaderRef
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub struct MessageHeader {
     /// User who constructed the message.
     pub sender: String,
@@ -297,7 +297,7 @@ impl SerializedMessage {
 }
 
 /// Handshake between client and server (peers do not use).
-#[derive(Eq, Hash, PartialEq)]
+#[derive(Eq, Debug, Hash, PartialEq)]
 pub struct Handshake {
     /// Who is sending this handshake.
     pub sender: String,
@@ -351,3 +351,168 @@ fn serialize_handshake(sender: &str, group: &str) -> Vec<u8> {
     debug_assert!(handshake.len() == handshake_len);
     handshake
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tokio::fs::{File, OpenOptions};
+
+    /// creates a temporary file for writing
+    async fn generate_tmp_file(name: &str) -> File {
+        let filename = format!("mgen-test-{}", name);
+        let mut path = std::env::temp_dir();
+        path.push(filename);
+        OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .open(path)
+            .await
+            .unwrap()
+    }
+
+    /// get an existing temp file for reading
+    async fn get_tmp_file(name: &str) -> File {
+        let filename = format!("mgen-test-{}", name);
+        let mut path = std::env::temp_dir();
+        path.push(filename);
+        OpenOptions::new().read(true).open(path).await.unwrap()
+    }
+
+    #[test]
+    fn serialize_deserialize_message() {
+        let m1 = MessageHeader {
+            sender: "Alice".to_string(),
+            group: "group".to_string(),
+            body: MessageBody::Size(NonZeroU32::new(256).unwrap()),
+        };
+
+        let serialized = m1.serialize();
+
+        let m2 = MessageHeader::deserialize(&serialized.header[4..]).unwrap();
+        assert_eq!(m1, m2);
+    }
+
+    #[test]
+    fn serialize_deserialize_receipt() {
+        let m1 = MessageHeader {
+            sender: "Alice".to_string(),
+            group: "group".to_string(),
+            body: MessageBody::Receipt,
+        };
+
+        let serialized = m1.serialize();
+
+        let m2 = MessageHeader::deserialize(&serialized.header[4..]).unwrap();
+        assert_eq!(m1, m2);
+    }
+
+    #[test]
+    fn deserialize_message_ref() {
+        let m1 = MessageHeader {
+            sender: "Alice".to_string(),
+            group: "group".to_string(),
+            body: MessageBody::Size(NonZeroU32::new(256).unwrap()),
+        };
+
+        let serialized = m1.serialize();
+
+        let m2 = MessageHeaderRef::deserialize(&serialized.header[4..]).unwrap();
+
+        assert_eq!(m1.sender, m2.sender);
+        assert_eq!(m1.group, m2.group);
+        assert_eq!(m1.body, m2.body);
+    }
+
+    #[test]
+    fn deserialize_receipt_ref() {
+        let m1 = MessageHeader {
+            sender: "Alice".to_string(),
+            group: "group".to_string(),
+            body: MessageBody::Receipt,
+        };
+
+        let serialized = m1.serialize();
+
+        let m2 = MessageHeaderRef::deserialize(&serialized.header[4..]).unwrap();
+
+        assert_eq!(m1.sender, m2.sender);
+        assert_eq!(m1.group, m2.group);
+        assert_eq!(m1.body, m2.body);
+    }
+
+    #[tokio::test]
+    async fn serialize_get_message() {
+        let m1 = MessageHeader {
+            sender: "Alice".to_string(),
+            group: "group".to_string(),
+            body: MessageBody::Size(NonZeroU32::new(256).unwrap()),
+        };
+
+        let serialized = m1.serialize();
+
+        let file_name = "serialize_message_get";
+        let mut f = generate_tmp_file(file_name).await;
+        serialized.write_all_to(&mut f).await.unwrap();
+
+        let mut f = get_tmp_file(file_name).await;
+        let m2 = get_message(&mut f).await.unwrap();
+
+        assert_eq!(m1, m2);
+    }
+
+    #[tokio::test]
+    async fn serialize_get_receipt() {
+        let m1 = MessageHeader {
+            sender: "Alice".to_string(),
+            group: "group".to_string(),
+            body: MessageBody::Receipt,
+        };
+
+        let serialized = m1.serialize();
+
+        let file_name = "serialize_receipt_get";
+        let mut f = generate_tmp_file(file_name).await;
+        serialized.write_all_to(&mut f).await.unwrap();
+
+        let mut f = get_tmp_file(file_name).await;
+        let m2 = get_message(&mut f).await.unwrap();
+
+        assert_eq!(m1, m2);
+    }
+
+    #[tokio::test]
+    async fn serialize_get_handshake() {
+        let h1 = Handshake {
+            sender: "Alice".to_string(),
+            group: "group".to_string(),
+        };
+
+        let file_name = "handshake";
+        let mut f = generate_tmp_file(file_name).await;
+        f.write_all(&h1.serialize()).await.unwrap();
+
+        let mut f = get_tmp_file(file_name).await;
+        let h2 = get_handshake(&mut f).await.unwrap();
+
+        assert_eq!(h1, h2);
+    }
+
+    #[tokio::test]
+    async fn serialize_get_handshake_ref() {
+        let h1 = HandshakeRef {
+            sender: "Alice",
+            group: "group",
+        };
+
+        let file_name = "handshake-ref";
+        let mut f = generate_tmp_file(file_name).await;
+        f.write_all(&h1.serialize()).await.unwrap();
+
+        let mut f = get_tmp_file(file_name).await;
+        let h2 = get_handshake(&mut f).await.unwrap();
+
+        assert_eq!(h1.sender, h2.sender);
+        assert_eq!(h1.group, h2.group);
+    }
+}