test(core): add tests, refactor codec, and improve coverage

libvctrl_core/src/codec/binary_encoder.rs

@@ -5,6 +5,7 @@ use std::io::Write;
 
 pub const VERSION: u8 = 3;
 
+#[derive(Debug, Default, Clone, Copy)]
 pub struct BinaryEncoder;
 
 impl Encoder for BinaryEncoder {
@@ -18,6 +19,7 @@ impl Encoder for BinaryEncoder {
         Ok(())
     }
 
+    #[allow(clippy::wildcard_enum_match_arm)]
     fn encode_tree<W: Write + Send>(&self, tree: &Tree, writer: &mut W) -> Result<(), VctrlError> {
         let entries = tree.entries();
         writer.write_all(&[VERSION]).map_err(VctrlError::from_io)?;
@@ -73,9 +75,9 @@ impl Encoder for BinaryEncoder {
             .write_all(&parent_count.to_le_bytes())
             .map_err(VctrlError::from_io)?;
 
-        for p in parents {
+        for parent in parents {
             writer
-                .write_all(p.as_bytes())
+                .write_all(parent.as_bytes())
                 .map_err(VctrlError::from_io)?;
         }
 
@@ -235,3 +237,308 @@ impl Encoder for BinaryEncoder {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use libvctrl_handler::{CommitMeta, HASH_LENGTH, Hash, UserID};
+    use std::io::Cursor;
+
+    fn make_hash(fill: u8) -> Hash {
+        Hash::from_bytes(&vec![fill; HASH_LENGTH]).unwrap()
+    }
+
+    fn hash_bytes(fill: u8) -> Vec<u8> {
+        vec![fill; HASH_LENGTH]
+    }
+
+    fn make_user_id(name: &str, email: &str) -> UserID {
+        UserID::new(name.into(), email.into()).unwrap()
+    }
+
+    fn make_meta(ts: i64, tz: i16, enc: Option<&str>) -> CommitMeta {
+        CommitMeta::new(ts, tz, enc.map(|s| s.into())).unwrap()
+    }
+
+    #[test]
+    fn test_encode_blob() {
+        let blob = Blob::new(vec![0x01, 0x02, 0x03]).unwrap();
+        let mut buf = Cursor::new(Vec::new());
+        BinaryEncoder.encode_blob(&blob, &mut buf).unwrap();
+        let encoded = buf.into_inner();
+
+        let mut expected = Vec::new();
+        expected.push(VERSION);
+        expected.extend_from_slice(&3u64.to_le_bytes());
+        expected.extend_from_slice(&[0x01, 0x02, 0x03]);
+        assert_eq!(encoded, expected);
+    }
+
+    #[test]
+    fn test_encode_blob_empty_data() {
+        let blob = Blob::new(vec![]).unwrap();
+        let mut buf = Cursor::new(Vec::new());
+        BinaryEncoder.encode_blob(&blob, &mut buf).unwrap();
+        let encoded = buf.into_inner();
+
+        let mut expected = Vec::new();
+        expected.push(VERSION);
+        expected.extend_from_slice(&0u64.to_le_bytes());
+        assert_eq!(encoded, expected);
+    }
+
+    #[test]
+    fn test_encode_tree_single_entry() {
+        let hash = make_hash(0xAB);
+        let entry = TreeEntry::new("README".into(), EntryKind::Blob, hash).unwrap();
+        let tree = Tree::new(vec![entry]).unwrap();
+        let mut buf = Cursor::new(Vec::new());
+        BinaryEncoder.encode_tree(&tree, &mut buf).unwrap();
+        let encoded = buf.into_inner();
+
+        let mut expected = Vec::new();
+        expected.push(VERSION);
+        expected.extend_from_slice(&1u32.to_le_bytes());
+        expected.push(6); // "README" length
+        expected.extend_from_slice(b"README");
+        expected.push(0); // Blob
+        expected.extend_from_slice(&hash_bytes(0xAB));
+        assert_eq!(encoded, expected);
+    }
+
+    #[test]
+    fn test_encode_tree_empty() {
+        let tree = Tree::new(vec![]).unwrap();
+        let mut buf = Cursor::new(Vec::new());
+        BinaryEncoder.encode_tree(&tree, &mut buf).unwrap();
+        let encoded = buf.into_inner();
+
+        let mut expected = Vec::new();
+        expected.push(VERSION);
+        expected.extend_from_slice(&0u32.to_le_bytes());
+        assert_eq!(encoded, expected);
+    }
+
+    #[test]
+    fn test_encode_tree_multiple_entries() {
+        let e1 = TreeEntry::new("src".into(), EntryKind::Tree, make_hash(0x01)).unwrap();
+        let e2 = TreeEntry::new("run".into(), EntryKind::Executable, make_hash(0x02)).unwrap();
+        let tree = Tree::new(vec![e1, e2]).unwrap();
+        let mut buf = Cursor::new(Vec::new());
+        BinaryEncoder.encode_tree(&tree, &mut buf).unwrap();
+        let encoded = buf.into_inner();
+
+        let mut expected = Vec::new();
+        expected.push(VERSION);
+        expected.extend_from_slice(&2u32.to_le_bytes());
+        expected.push(3);
+        expected.extend_from_slice(b"src");
+        expected.push(3); // Tree
+        expected.extend_from_slice(&hash_bytes(0x01));
+        expected.push(3);
+        expected.extend_from_slice(b"run");
+        expected.push(1); // Executable
+        expected.extend_from_slice(&hash_bytes(0x02));
+        assert_eq!(encoded, expected);
+    }
+
+    #[test]
+    fn test_encode_commit() {
+        let commit = Commit::with_meta(
+            make_hash(0x01),
+            vec![],
+            make_user_id("Alice", "a@b.c"),
+            make_user_id("Bob", "b@c.d"),
+            "init".into(),
+            make_meta(1700000000, 0, None),
+        )
+        .unwrap();
+        let mut buf = Cursor::new(Vec::new());
+        BinaryEncoder.encode_commit(&commit, &mut buf).unwrap();
+        let encoded = buf.into_inner();
+
+        let mut expected = Vec::new();
+        expected.push(VERSION);
+        expected.extend_from_slice(&hash_bytes(0x01));
+        expected.extend_from_slice(&0u16.to_le_bytes());
+        expected.push(5);
+        expected.extend_from_slice(b"Alice");
+        expected.push(5);
+        expected.extend_from_slice(b"a@b.c");
+        expected.push(3);
+        expected.extend_from_slice(b"Bob");
+        expected.push(5);
+        expected.extend_from_slice(b"b@c.d");
+        expected.extend_from_slice(&4u32.to_le_bytes());
+        expected.extend_from_slice(b"init");
+        expected.extend_from_slice(&1700000000i64.to_le_bytes());
+        expected.extend_from_slice(&0i16.to_le_bytes());
+        expected.push(0);
+        assert_eq!(encoded, expected);
+    }
+
+    #[test]
+    fn test_encode_commit_with_encoding() {
+        let commit = Commit::with_meta(
+            make_hash(0x01),
+            vec![],
+            make_user_id("A", "a@b.c"),
+            make_user_id("B", "b@c.d"),
+            "msg".into(),
+            make_meta(1700000000, 3600, Some("UTF-8")),
+        )
+        .unwrap();
+        let mut buf = Cursor::new(Vec::new());
+        BinaryEncoder.encode_commit(&commit, &mut buf).unwrap();
+        let encoded = buf.into_inner();
+
+        let mut expected = Vec::new();
+        expected.push(VERSION);
+        expected.extend_from_slice(&hash_bytes(0x01));
+        expected.extend_from_slice(&0u16.to_le_bytes());
+        expected.push(1);
+        expected.extend_from_slice(b"A");
+        expected.push(5);
+        expected.extend_from_slice(b"a@b.c");
+        expected.push(1);
+        expected.extend_from_slice(b"B");
+        expected.push(5);
+        expected.extend_from_slice(b"b@c.d");
+        expected.extend_from_slice(&3u32.to_le_bytes());
+        expected.extend_from_slice(b"msg");
+        expected.extend_from_slice(&1700000000i64.to_le_bytes());
+        expected.extend_from_slice(&3600i16.to_le_bytes());
+        expected.push(5);
+        expected.extend_from_slice(b"UTF-8");
+        assert_eq!(encoded, expected);
+    }
+
+    #[test]
+    fn test_encode_commit_with_parents() {
+        let commit = Commit::with_meta(
+            make_hash(0x01),
+            vec![make_hash(0x02), make_hash(0x03)],
+            make_user_id("A", "a@b.c"),
+            make_user_id("B", "b@c.d"),
+            "merge".into(),
+            make_meta(0, 0, None),
+        )
+        .unwrap();
+        let mut buf = Cursor::new(Vec::new());
+        BinaryEncoder.encode_commit(&commit, &mut buf).unwrap();
+        let encoded = buf.into_inner();
+
+        let mut expected = Vec::new();
+        expected.push(VERSION);
+        expected.extend_from_slice(&hash_bytes(0x01));
+        expected.extend_from_slice(&2u16.to_le_bytes());
+        expected.extend_from_slice(&hash_bytes(0x02));
+        expected.extend_from_slice(&hash_bytes(0x03));
+        expected.push(1);
+        expected.extend_from_slice(b"A");
+        expected.push(5);
+        expected.extend_from_slice(b"a@b.c");
+        expected.push(1);
+        expected.extend_from_slice(b"B");
+        expected.push(5);
+        expected.extend_from_slice(b"b@c.d");
+        expected.extend_from_slice(&5u32.to_le_bytes());
+        expected.extend_from_slice(b"merge");
+        expected.extend_from_slice(&0i64.to_le_bytes());
+        expected.extend_from_slice(&0i16.to_le_bytes());
+        expected.push(0);
+        assert_eq!(encoded, expected);
+    }
+
+    #[test]
+    fn test_encode_tag_with_tagger() {
+        let tag = Tag::with_meta(
+            "v1.0".into(),
+            make_hash(0x10),
+            Some(make_user_id("Alice", "alice@ex.com")),
+            "release".into(),
+            make_meta(1700000000, 0, None),
+        )
+        .unwrap();
+        let mut buf = Cursor::new(Vec::new());
+        BinaryEncoder.encode_tag(&tag, &mut buf).unwrap();
+        let encoded = buf.into_inner();
+
+        let mut expected = Vec::new();
+        expected.push(VERSION);
+        expected.push(4); // "v1.0" length
+        expected.extend_from_slice(b"v1.0");
+        expected.extend_from_slice(&hash_bytes(0x10));
+        expected.push(1); // has tagger
+        expected.push(5);
+        expected.extend_from_slice(b"Alice");
+        expected.push(11);
+        expected.extend_from_slice(b"alice@ex.com");
+        expected.extend_from_slice(&7u32.to_le_bytes());
+        expected.extend_from_slice(b"release");
+        expected.extend_from_slice(&1700000000i64.to_le_bytes());
+        expected.extend_from_slice(&0i16.to_le_bytes());
+        expected.push(0);
+        assert_eq!(encoded, expected);
+    }
+
+    #[test]
+    fn test_encode_tag_no_tagger() {
+        let tag = Tag::with_meta(
+            "v2.0".into(),
+            make_hash(0x20),
+            None,
+            "".into(),
+            make_meta(1700000000, 0, None),
+        )
+        .unwrap();
+        let mut buf = Cursor::new(Vec::new());
+        BinaryEncoder.encode_tag(&tag, &mut buf).unwrap();
+        let encoded = buf.into_inner();
+
+        let mut expected = Vec::new();
+        expected.push(VERSION);
+        expected.push(4);
+        expected.extend_from_slice(b"v2.0");
+        expected.extend_from_slice(&hash_bytes(0x20));
+        expected.push(0); // no tagger
+        expected.extend_from_slice(&0u32.to_le_bytes());
+        expected.extend_from_slice(&1700000000i64.to_le_bytes());
+        expected.extend_from_slice(&0i16.to_le_bytes());
+        expected.push(0);
+        assert_eq!(encoded, expected);
+    }
+
+    #[test]
+    fn test_encode_tag_with_encoding() {
+        let tag = Tag::with_meta(
+            "v3".into(),
+            make_hash(0x30),
+            Some(make_user_id("B", "b@c.d")),
+            "tag".into(),
+            make_meta(1700000000, -3600, Some("UTF-8")),
+        )
+        .unwrap();
+        let mut buf = Cursor::new(Vec::new());
+        BinaryEncoder.encode_tag(&tag, &mut buf).unwrap();
+        let encoded = buf.into_inner();
+
+        let mut expected = Vec::new();
+        expected.push(VERSION);
+        expected.push(2); // "v3" length
+        expected.extend_from_slice(b"v3");
+        expected.extend_from_slice(&hash_bytes(0x30));
+        expected.push(1);
+        expected.push(1);
+        expected.extend_from_slice(b"B");
+        expected.push(5);
+        expected.extend_from_slice(b"b@c.d");
+        expected.extend_from_slice(&3u32.to_le_bytes());
+        expected.extend_from_slice(b"tag");
+        expected.extend_from_slice(&1700000000i64.to_le_bytes());
+        expected.extend_from_slice(&(-3600i16).to_le_bytes());
+        expected.push(5);
+        expected.extend_from_slice(b"UTF-8");
+        assert_eq!(encoded, expected);
+    }
+}