feat: add tests (unfinished)

Author: eerii

build.rs

@@ -5,11 +5,7 @@ pub fn main() {
 
 #[cfg(feature = "binary")]
 mod binary {
-    use std::{
-        collections::HashMap,
-        fs,
-        path::{Path, PathBuf},
-    };
+    use std::{collections::HashMap, fs, path::Path};
 
     use system_deps_meta::{read_metadata, Binary, BinaryPaths, BUILD_TARGET_DIR};
 
@@ -21,8 +17,7 @@ mod binary {
         println!("cargo:rustc-env=BINARY_CONFIG={}", dest_path.display());
 
         // Read metadata from the crate graph
-        let manifest = PathBuf::from(system_deps_meta::BUILD_MANIFEST);
-        let metadata = read_metadata(&manifest, "system-deps");
+        let metadata = read_metadata(system_deps_meta::BUILD_MANIFEST, "system-deps");
 
         // Download the binaries and get their pkg_config paths
         let mut binaries = metadata

meta/src/binary.rs

@@ -52,12 +52,12 @@ pub struct Binary {
     /// The `system-deps` formatted name of another library which has binaries specified.
     /// This library will alias the configuration of the followed one. If `url` is specified
     /// alongside this field, it will no longer follow the original configuration.
-    follows: Option<String>,
+    _follows: Option<String>,
 }
 
 impl Binary {
     pub fn paths(&self, name: &str) -> Result<HashSet<PathBuf>, Error> {
-        // Set this binary to follow
+        // TODO: Set this binary to follow
         //if let Some(follows) = self.follows {
         //    follow_list.insert(name.clone(), follows);
         //}
@@ -176,7 +176,7 @@ pub fn get_path(name: &str) -> &[&'static str] {{
 /// Checks if the target directory is valid and if binaries need to be redownloaded.
 /// On an `Ok` result, if the value is true it means that the directory is correct.
 fn check_valid_dir(dst: &Path, checksum: Option<&str>) -> Result<bool, Error> {
-    let e = |e| Error::InvalidDirectory(e);
+    let e = Error::InvalidDirectory;
 
     // If it doesn't exist yet the download will need to happen
     if !dst.try_exists().map_err(e)? {
@@ -224,7 +224,7 @@ fn download(url: &str, dst: &Path) -> Result<(), Error> {
         let path = Path::new(file_path);
         match ext {
             Ok(ext) => {
-                let file = fs::read(path).map_err(|e| Error::LocalFileError(e))?;
+                let file = fs::read(path).map_err(Error::LocalFileError)?;
                 decompress(&file, dst, ext)?;
             }
             Err(e) => {
@@ -234,11 +234,10 @@ fn download(url: &str, dst: &Path) -> Result<(), Error> {
                 }
                 if !dst.read_link().is_ok_and(|l| l == path) {
                     #[cfg(unix)]
-                    std::os::unix::fs::symlink(file_path, dst)
-                        .map_err(|e| Error::SymlinkError(e))?;
+                    std::os::unix::fs::symlink(file_path, dst).map_err(Error::SymlinkError)?;
                     #[cfg(windows)]
                     std::os::windows::fs::symlink_dir(file_path, dst)
-                        .map_err(|e| Error::SymlinkError(e))?;
+                        .map_err(Error::SymlinkError)?;
                 }
             }
         };
@@ -250,7 +249,9 @@ fn download(url: &str, dst: &Path) -> Result<(), Error> {
         #[cfg(feature = "web")]
         {
             let ext = ext?;
-            let file = reqwest::blocking::get(url).and_then(|req| req.bytes())?;
+            let file = reqwest::blocking::get(url)
+                .and_then(|req| req.bytes())
+                .map_err(Error::DownloadError)?;
             decompress(&file, dst, ext)?;
         }
     }
@@ -265,7 +266,7 @@ fn download(url: &str, dst: &Path) -> Result<(), Error> {
 fn decompress(file: &[u8], dst: &Path, ext: Extension) -> Result<(), Error> {
     #[cfg(any(feature = "gz", feature = "xz", feature = "zip", feature = "pkg"))]
     {
-        let e = |e| Error::DecompressError(e);
+        let e = Error::DecompressError;
 
         match ext {
             #[cfg(feature = "gz")]

meta/src/lib.rs

@@ -20,33 +20,33 @@ pub const BUILD_TARGET_DIR: &str = env!("BUILD_TARGET_DIR");
 /// Metadata related errors.
 #[derive(Debug)]
 pub enum Error {
+    // Meta
+    PackageNotFound(String),
+    IncompatibleMerge,
+    SerializationError(serde_json::Error),
     // Binary
     DecompressError(io::Error),
+    DownloadError(reqwest::Error),
     DirectoryIsFile(String),
     InvalidDirectory(io::Error),
     InvalidExtension(String),
     LocalFileError(io::Error),
     SymlinkError(io::Error),
-    // Web
-    DownloadError(reqwest::Error),
-}
-
-impl From<reqwest::Error> for Error {
-    fn from(e: reqwest::Error) -> Self {
-        Self::DownloadError(e)
-    }
 }
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
+            Error::PackageNotFound(pkg) => write!(f, "Package not found {}", pkg),
+            Error::IncompatibleMerge => write!(f, "Can't merge metadata"),
+            Error::SerializationError(e) => write!(f, "Error while parsing: {:?}", e),
             Error::DecompressError(e) => {
                 write!(f, "Error while decompressing the binaries: {:?}", e)
             }
-            Error::DirectoryIsFile(dir) => write!(f, "The target directory is a file {:?}", dir),
+            Error::DirectoryIsFile(dir) => write!(f, "The target directory is a file {}", dir),
             Error::InvalidDirectory(e) => write!(f, "The binary directory is not valid: {:?}", e),
             Error::InvalidExtension(url) => {
-                write!(f, "Unsuppported binary extension for {:?}", url)
+                write!(f, "Unsuppported binary extension for {}", url)
             }
             Error::LocalFileError(e) => {
                 write!(f, "Error reading the local binary file: {:?}", e)