feat: add unit tests for cpio and compression modules (#2)

Author: axelfrache

src/initramfs/compress.rs

@@ -78,3 +78,86 @@ pub fn compress_archive(data: &[u8], output_path: &Path, compression: Compressio
 
     Ok(output_size)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use std::io::Read;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_compression_from_str() {
+        assert_eq!("gzip".parse::<Compression>().unwrap(), Compression::Gzip);
+        assert_eq!("gz".parse::<Compression>().unwrap(), Compression::Gzip);
+        assert_eq!("zstd".parse::<Compression>().unwrap(), Compression::Zstd);
+        assert_eq!("zst".parse::<Compression>().unwrap(), Compression::Zstd);
+        assert_eq!("none".parse::<Compression>().unwrap(), Compression::None);
+        assert_eq!("raw".parse::<Compression>().unwrap(), Compression::None);
+        assert!("invalid".parse::<Compression>().is_err());
+    }
+
+    #[test]
+    fn test_compression_display() {
+        assert_eq!(format!("{}", Compression::Gzip), "gzip");
+        assert_eq!(format!("{}", Compression::Zstd), "zstd");
+        assert_eq!(format!("{}", Compression::None), "none");
+    }
+
+    #[test]
+    fn test_compression_default() {
+        assert_eq!(Compression::default(), Compression::Gzip);
+    }
+
+    #[test]
+    fn test_gzip_compression() {
+        let temp_dir = TempDir::new().unwrap();
+        let output_path = temp_dir.path().join("test.gz");
+        // Use repetitive data that compresses well
+        let data: Vec<u8> = b"hello world ".repeat(100).to_vec();
+
+        let size = compress_archive(&data, &output_path, Compression::Gzip).unwrap();
+
+        assert!(output_path.exists());
+        assert!(size > 0);
+
+        // Verify it's valid gzip and decompresses correctly
+        let file = File::open(&output_path).unwrap();
+        let mut decoder = flate2::read::GzDecoder::new(file);
+        let mut decompressed = Vec::new();
+        decoder.read_to_end(&mut decompressed).unwrap();
+        assert_eq!(decompressed, data);
+    }
+
+    #[test]
+    fn test_zstd_compression() {
+        let temp_dir = TempDir::new().unwrap();
+        let output_path = temp_dir.path().join("test.zst");
+        let data = b"hello world hello world hello world";
+
+        let size = compress_archive(data, &output_path, Compression::Zstd).unwrap();
+
+        assert!(output_path.exists());
+        assert!(
+            size < data.len() as u64,
+            "Compressed size should be smaller"
+        );
+
+        // Verify it's valid zstd
+        let compressed = fs::read(&output_path).unwrap();
+        let decompressed = zstd::decode_all(&compressed[..]).unwrap();
+        assert_eq!(decompressed, data);
+    }
+
+    #[test]
+    fn test_no_compression() {
+        let temp_dir = TempDir::new().unwrap();
+        let output_path = temp_dir.path().join("test.cpio");
+        let data = b"hello world";
+
+        let size = compress_archive(data, &output_path, Compression::None).unwrap();
+
+        assert_eq!(size, data.len() as u64);
+        assert_eq!(fs::read(&output_path).unwrap(), data);
+    }
+}

src/initramfs/cpio.rs

@@ -188,3 +188,95 @@ impl Default for CpioArchive {
         Self::new()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_empty_archive() {
+        let archive = CpioArchive::new();
+        assert!(archive.is_empty());
+        assert_eq!(archive.len(), 0);
+    }
+
+    #[test]
+    fn test_archive_from_directory() {
+        let temp_dir = TempDir::new().unwrap();
+        let file_path = temp_dir.path().join("test.txt");
+        fs::write(&file_path, b"hello world").unwrap();
+
+        let archive = CpioArchive::from_directory(temp_dir.path()).unwrap();
+        assert_eq!(archive.len(), 1);
+    }
+
+    #[test]
+    fn test_cpio_header_magic() {
+        let temp_dir = TempDir::new().unwrap();
+        let file_path = temp_dir.path().join("test.txt");
+        fs::write(&file_path, b"test").unwrap();
+
+        let archive = CpioArchive::from_directory(temp_dir.path()).unwrap();
+        let mut output = Vec::new();
+        archive.write_to(&mut output).unwrap();
+
+        let header = String::from_utf8_lossy(&output[..6]);
+        assert_eq!(header, "070701", "CPIO header should start with newc magic");
+    }
+
+    #[test]
+    fn test_cpio_trailer() {
+        let archive = CpioArchive::new();
+        let mut output = Vec::new();
+        archive.write_to(&mut output).unwrap();
+
+        let output_str = String::from_utf8_lossy(&output);
+        assert!(
+            output_str.contains("TRAILER!!!"),
+            "Archive should end with TRAILER!!!"
+        );
+    }
+
+    #[test]
+    fn test_multiple_files() {
+        let temp_dir = TempDir::new().unwrap();
+        fs::write(temp_dir.path().join("a.txt"), b"aaa").unwrap();
+        fs::write(temp_dir.path().join("b.txt"), b"bbb").unwrap();
+        fs::create_dir(temp_dir.path().join("subdir")).unwrap();
+        fs::write(temp_dir.path().join("subdir/c.txt"), b"ccc").unwrap();
+
+        let archive = CpioArchive::from_directory(temp_dir.path()).unwrap();
+        assert_eq!(archive.len(), 4); // 3 files + 1 directory
+    }
+
+    #[test]
+    fn test_symlink_handling() {
+        let temp_dir = TempDir::new().unwrap();
+        let target = temp_dir.path().join("target.txt");
+        let link = temp_dir.path().join("link.txt");
+        fs::write(&target, b"target content").unwrap();
+
+        #[cfg(unix)]
+        std::os::unix::fs::symlink(&target, &link).unwrap();
+
+        let archive = CpioArchive::from_directory(temp_dir.path()).unwrap();
+
+        #[cfg(unix)]
+        assert_eq!(archive.len(), 2);
+    }
+
+    #[test]
+    fn test_output_alignment() {
+        let temp_dir = TempDir::new().unwrap();
+        fs::write(temp_dir.path().join("odd.txt"), b"123").unwrap(); // 3 bytes, needs padding
+
+        let archive = CpioArchive::from_directory(temp_dir.path()).unwrap();
+        let mut output = Vec::new();
+        archive.write_to(&mut output).unwrap();
+
+        // Output should be 4-byte aligned
+        assert_eq!(output.len() % 4, 0, "CPIO output should be 4-byte aligned");
+    }
+}