[Improvement]: Add list, remove, clear, and size operations to shuttle-persist

resources/persist/.gitignore

@@ -0,0 +1,2 @@
+# output files from tests
+shuttle_persist/**/*.bin

resources/persist/Cargo.toml

@@ -12,3 +12,6 @@ bincode = "1.2.1"
 serde = { version = "1.0.0", features = ["derive"] }
 shuttle-service = { path = "../../service", version = "0.21.0" }
 thiserror = "1.0.32"
+
+[dev-dependencies]
+rand = "0.8.5"

resources/persist/src/lib.rs

@@ -16,6 +16,12 @@ pub enum PersistError {
     Open(std::io::Error),
     #[error("failed to create folder: {0}")]
     CreateFolder(std::io::Error),
+    #[error("failed to list contents of folder: {0}")]
+    ListFolder(std::io::Error),
+    #[error("failed to clear folder: {0}")]
+    RemoveFolder(std::io::Error),
+    #[error("failed to remove file: {0}")]
+    RemoveFile(std::io::Error),
     #[error("failed to serialize data: {0}")]
     Serialize(BincodeError),
     #[error("failed to deserialize data: {0}")]
@@ -41,6 +47,47 @@ impl PersistInstance {
         Ok(serialize_into(&mut writer, &struc).map_err(PersistError::Serialize))?
     }
 
+    /// list method returns a vector of strings containing all the keys associated with a PersistInstance
+    pub fn list(&self) -> Result<Vec<String>, PersistError> {
+        let storage_folder = self.get_storage_folder();
+
+        let mut list = Vec::new();
+
+        let entries = fs::read_dir(storage_folder).map_err(PersistError::ListFolder)?;
+        for entry in entries {
+            let key = entry.map_err(PersistError::ListFolder)?;
+            let key_name = key
+                .path()
+                .file_stem()
+                .unwrap_or_default()
+                .to_str()
+                .unwrap_or("file name contains non-UTF-8 characters")
+                .to_string();
+            list.push(key_name);
+        }
+        Ok(list)
+    }
+
+    /// clear method removes the keys within the PersistInstance
+    pub fn clear(&self) -> Result<(), PersistError> {
+        let storage_folder = self.get_storage_folder();
+        fs::remove_dir_all(&storage_folder).map_err(PersistError::RemoveFolder)?;
+        fs::create_dir_all(&storage_folder).map_err(PersistError::CreateFolder)?;
+        Ok(())
+    }
+
+    /// size method returns the number of keys in a folder within a PersistInstance
+    pub fn size(&self) -> Result<usize, PersistError> {
+        Ok(self.list()?.len())
+    }
+
+    /// remove method deletes a key from the PersistInstance
+    pub fn remove(&self, key: &str) -> Result<(), PersistError> {
+        let file_path = self.get_storage_file(key);
+        fs::remove_file(file_path).map_err(PersistError::RemoveFile)?;
+        Ok(())
+    }
+
     pub fn load<T>(&self, key: &str) -> Result<T, PersistError>
     where
         T: DeserializeOwned,
@@ -111,13 +158,95 @@ mod tests {
         assert_eq!(result, "test");
     }
 
+    #[test]
+    fn test_list_and_size() {
+        let persist = PersistInstance {
+            service_name: ServiceName::from_str("test1").unwrap(),
+        };
+
+        persist.save("test", "test").unwrap();
+        let list_result = persist.list().unwrap().len();
+        let size_result = persist.size().unwrap();
+        assert_eq!(list_result, 1);
+        assert_eq!(size_result, 1);
+    }
+
+    #[test]
+    fn test_list_error() {
+        let persist = PersistInstance {
+            service_name: ServiceName::from_str("test2").unwrap(),
+        };
+
+        // unwrap error
+        let result = persist.list().unwrap_err();
+        assert_eq!(
+            result.to_string(),
+            "failed to list contents of folder: No such file or directory (os error 2)"
+        );
+    }
+
+    #[test]
+    fn test_remove() {
+        let persist = PersistInstance {
+            service_name: ServiceName::from_str("test3").unwrap(),
+        };
+
+        persist.save("test", "test").unwrap();
+        persist.save("test2", "test2").unwrap();
+        let list = persist.list().unwrap();
+        let key = list[0].as_str();
+        persist.remove(key).unwrap();
+        let result = persist.list().unwrap();
+        assert_eq!(result.len(), 1);
+    }
+
+    #[test]
+    fn test_remove_error() {
+        let persist = PersistInstance {
+            service_name: ServiceName::from_str("test4").unwrap(),
+        };
+
+        // unwrap error
+        let result = persist.remove("test4").unwrap_err();
+        assert_eq!(
+            result.to_string(),
+            "failed to remove file: No such file or directory (os error 2)"
+        );
+    }
+
+    #[test]
+    fn test_clear() {
+        let persist = PersistInstance {
+            service_name: ServiceName::from_str("test5").unwrap(),
+        };
+
+        persist.save("test5", "test5").unwrap();
+        persist.clear().unwrap();
+        let result = persist.list().unwrap();
+        assert_eq!(result.len(), 0);
+    }
+
+    #[test]
+    fn test_clear_error() {
+        let persist = PersistInstance {
+            service_name: ServiceName::from_str("test6").unwrap(),
+        };
+
+        // unwrap error
+        let result = persist.clear().unwrap_err();
+        assert_eq!(
+            result.to_string(),
+            "failed to clear folder: No such file or directory (os error 2)"
+        );
+    }
+
     #[test]
     fn test_load_error() {
         let persist = PersistInstance {
             service_name: ServiceName::from_str("test").unwrap(),
         };
 
-        // unwrapp error
+        // unwrap error
         let result = persist.load::<String>("error").unwrap_err();
         assert_eq!(
             result.to_string(),