Fix tool-cache path issue (#42)

In a previous refactor, foreman paths we changed and the tool cache file
usage was missed. This fixes the issue and add unit tests to pin the
behavior.

Author: oltrep

src/paths.rs

@@ -48,7 +48,7 @@ impl ForemanPaths {
         self.root_dir.clone()
     }
 
-    pub fn from_root<P: AsRef<Path>>(&self, path: P) -> PathBuf {
+    fn from_root<P: AsRef<Path>>(&self, path: P) -> PathBuf {
         let mut dir = self.root_dir();
         dir.push(path);
         dir
@@ -71,7 +71,7 @@ impl ForemanPaths {
     }
 
     pub fn index_file(&self) -> PathBuf {
-        self.from_root("tool-cache.toml")
+        self.from_root("tool-cache.json")
     }
 
     pub fn create_all(&self) -> Result<(), ForemanError> {
@@ -96,3 +96,61 @@ impl Default for ForemanPaths {
         Self::new(root_dir)
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn root_dir() {
+        let root = PathBuf::from("/foreman");
+        let paths = ForemanPaths::new(root.clone());
+
+        assert_eq!(paths.root_dir(), root);
+    }
+
+    #[test]
+    fn tools_dir() {
+        let mut directory = PathBuf::from("/foreman");
+        let paths = ForemanPaths::new(directory.clone());
+        directory.push("tools");
+
+        assert_eq!(directory, paths.tools_dir());
+    }
+
+    #[test]
+    fn bin_dir() {
+        let mut directory = PathBuf::from("/foreman");
+        let paths = ForemanPaths::new(directory.clone());
+        directory.push("bin");
+
+        assert_eq!(directory, paths.bin_dir());
+    }
+
+    #[test]
+    fn auth_store() {
+        let mut directory = PathBuf::from("/foreman");
+        let paths = ForemanPaths::new(directory.clone());
+        directory.push("auth.toml");
+
+        assert_eq!(directory, paths.auth_store());
+    }
+
+    #[test]
+    fn user_config() {
+        let mut directory = PathBuf::from("/foreman");
+        let paths = ForemanPaths::new(directory.clone());
+        directory.push("foreman.toml");
+
+        assert_eq!(directory, paths.user_config());
+    }
+
+    #[test]
+    fn index_file() {
+        let mut directory = PathBuf::from("/foreman");
+        let paths = ForemanPaths::new(directory.clone());
+        directory.push("tool-cache.json");
+
+        assert_eq!(directory, paths.index_file());
+    }
+}

src/tool_cache.rs

@@ -22,14 +22,21 @@ use crate::{
 };
 
 /// Contains the current state of all of the tools that Foreman manages.
-#[derive(Debug, Default, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 pub struct ToolCache {
     pub tools: HashMap<CiString, ToolEntry>,
     #[serde(skip)]
     paths: ForemanPaths,
 }
 
 impl ToolCache {
+    pub fn new(paths: &ForemanPaths) -> Self {
+        Self {
+            tools: Default::default(),
+            paths: paths.clone(),
+        }
+    }
+
     pub fn run(&self, tool: &ToolSpec, version: &Version, args: Vec<String>) -> ForemanResult<i32> {
         let tool_path = self.get_tool_exe_path(tool, version);
 
@@ -173,13 +180,15 @@ impl ToolCache {
     }
 
     pub fn load(paths: &ForemanPaths) -> ForemanResult<Self> {
-        let mut tool_cache = fs::try_read(paths.index_file())?
+        let path = paths.index_file();
+        log::debug!("load tool cache from {}", path.display());
+
+        let mut tool_cache = fs::try_read(&path)?
             .map(|contents| {
-                serde_json::from_slice(&contents).map_err(|err| {
-                    ForemanError::tool_cache_parsing(paths.index_file(), err.to_string())
-                })
+                serde_json::from_slice(&contents)
+                    .map_err(|err| ForemanError::tool_cache_parsing(&path, err.to_string()))
             })
-            .unwrap_or_else(|| Ok(Self::default()))?;
+            .unwrap_or_else(|| Ok(Self::new(paths)))?;
 
         tool_cache.paths = paths.clone();
         Ok(tool_cache)
@@ -188,7 +197,7 @@ impl ToolCache {
     fn save(&self) -> ForemanResult<()> {
         let serialized =
             serde_json::to_string_pretty(self).expect("unable to serialize tool cache");
-        fs::write(self.index_file(), serialized)
+        fs::write(self.paths.index_file(), serialized)
     }
 
     fn get_tool_exe_path(&self, tool: &ToolSpec, version: &Version) -> PathBuf {
@@ -197,15 +206,9 @@ impl ToolCache {
         tool_path.push(exe_name);
         tool_path
     }
-
-    fn index_file(&self) -> PathBuf {
-        let mut path = self.paths.root_dir();
-        path.push("tool-cache.json");
-        path
-    }
 }
 
-#[derive(Debug, Default, Serialize, Deserialize)]
+#[derive(Debug, Default, PartialEq, Serialize, Deserialize)]
 pub struct ToolEntry {
     pub versions: BTreeSet<Version>,
 }
@@ -215,3 +218,87 @@ fn tool_identifier_to_exe_name(tool: &ToolSpec, version: &Version) -> String {
     name = name.replace('/', "__");
     name.replace('\\', "__")
 }
+
+#[cfg(test)]
+mod test {
+    use tempfile::tempdir;
+
+    use super::*;
+
+    mod load {
+        use super::*;
+
+        #[test]
+        fn use_default_when_tool_cache_file_does_not_exist() {
+            let foreman_root = tempdir().expect("unable to create temporary directory");
+            let paths = ForemanPaths::new(foreman_root.into_path());
+
+            let cache = ToolCache::load(&paths).unwrap();
+
+            assert_eq!(cache, ToolCache::new(&paths));
+        }
+
+        #[test]
+        fn reads_the_content_from_the_cache_file() {
+            let foreman_root = tempdir().expect("unable to create temporary directory");
+            let paths = ForemanPaths::new(foreman_root.into_path());
+
+            fs::write(
+                paths.index_file(),
+                r#"
+            {
+                "tools": {
+                    "username/toolname": {
+                        "versions": [
+                            "0.1.0"
+                        ]
+                    }
+                }
+            }
+            "#,
+            )
+            .unwrap();
+
+            let cache = ToolCache::load(&paths).unwrap();
+
+            let mut expected_cache = ToolCache::new(&paths);
+
+            expected_cache.tools.insert(
+                "username/toolname".into(),
+                ToolEntry {
+                    versions: {
+                        let mut tree = BTreeSet::new();
+                        tree.insert(Version::parse("0.1.0").unwrap());
+                        tree
+                    },
+                },
+            );
+
+            assert_eq!(cache, expected_cache);
+        }
+    }
+
+    mod save {
+        use super::*;
+
+        #[test]
+        fn snapshot_default_tool_cache() {
+            let foreman_root = tempdir().expect("unable to create temporary directory");
+            let paths = ForemanPaths::new(foreman_root.into_path());
+
+            let cache = ToolCache::new(&paths);
+
+            cache.save().unwrap();
+
+            let content = fs::try_read_to_string(paths.index_file())
+                .unwrap()
+                .expect("unable to find tool cache file");
+
+            insta::assert_snapshot!(&content, @r###"
+            {
+              "tools": {}
+            }
+            "###);
+        }
+    }
+}