feat: ✨ client read all, read, download, delete

fix: 🚑 creating table instead of record in database

client/src/file.rs

@@ -3,10 +3,11 @@ use tokio::{
     io::AsyncWriteExt,
 };
 
-const FILE_LOCATION: &str = "~/.local/share/";
+const FILE_LOCATION: &str = "./packages/";
 
 pub async fn save_package(package_name: String, package_data: &[u8]) -> Result<(), std::io::Error> {
-    let mut package_file = File::create_new(format!("{}{}", FILE_LOCATION, package_name)).await?;
+    let file_location = format!("{}{}", FILE_LOCATION, package_name);
+    let mut package_file = File::create(file_location).await?;
     package_file.write_all(package_data).await
 }
 

client/src/package.rs

@@ -14,6 +14,28 @@ pub struct Package {
     location: String,
 }
 
+impl Package {
+    pub fn get_name(&self) -> String {
+        self.name.clone()
+    }
+}
+
+impl Default for Package {
+    fn default() -> Self {
+        Self {
+            name: Default::default(),
+            publisher: Default::default(),
+            version: Default::default(),
+            size: Default::default(),
+            hash: Default::default(),
+            dependencies: Default::default(),
+            publish_date_time: Default::default(),
+            last_update_date_time: Default::default(),
+            location: Default::default(),
+        }
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Version {
     first: u8,
@@ -21,7 +43,25 @@ pub struct Version {
     third: u8,
 }
 
+impl Default for Version {
+    fn default() -> Self {
+        Self {
+            first: Default::default(),
+            second: Default::default(),
+            third: Default::default(),
+        }
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Publisher {
     name: String,
 }
+
+impl Default for Publisher {
+    fn default() -> Self {
+        Self {
+            name: Default::default(),
+        }
+    }
+}

client/src/request.rs

@@ -16,7 +16,8 @@ pub async fn read_all_packages() -> Result<Vec<Package>, Box<dyn Error>> {
         .as_array()
         .map_or(Err(""), |values| Ok(values))?
         .iter()
-        .map(|value| serde_json::from_value::<Package>(value.clone()).unwrap())
+        .map(|value| serde_json::from_value::<Package>(value.clone()).unwrap_or_default())
+        .filter(|package| !package.get_name().is_empty())
         .collect())
 }
 
@@ -34,14 +35,13 @@ pub async fn read_package(package_name: String) -> Option<Package> {
 pub async fn download_package(package_name: String) -> Option<Vec<u8>> {
     Some(
         CLIENT
-            .get(format!("{}{}/{}", URL, "/packages", package_name))
+            .get(format!("{}{}/{}", URL, "/packages/downloads", package_name))
             .send()
             .await
             .ok()?
-            .text()
+            .bytes()
             .await
             .ok()?
-            .as_bytes()
             .to_vec(),
     )
 }

client/src/test.rs

@@ -2,11 +2,62 @@
 use tokio::test;
 
 #[test]
-async fn test_list_packages() {
+async fn test_read_all_packages() {
     use crate::request::read_all_packages;
 
     let packages = read_all_packages().await;
 
-    println!("{:#?}", packages);
     assert_eq!(packages.is_ok(), true);
+    assert_eq!(packages.as_ref().unwrap().is_empty(), false);
+}
+
+#[test]
+async fn test_read_package() {
+    use crate::request::read_package;
+
+    let package = read_package("test_package".to_owned()).await;
+    assert_eq!(package.is_some(), true);
+    assert_eq!(package.unwrap().get_name().is_empty(), false);
+}
+
+#[test]
+async fn test_download_package() {
+    use crate::request::download_package;
+
+    let package_data = download_package("test_package".to_owned()).await;
+    assert_eq!(package_data.is_some(), true);
+    assert_eq!(package_data.unwrap().is_empty(), false);
+}
+
+#[test]
+async fn test_save_package() {
+    use crate::request::download_package;
+
+    let package_data = download_package("test_package".to_owned()).await;
+    assert_eq!(package_data.is_some(), true);
+    assert_eq!(package_data.as_ref().unwrap().is_empty(), false);
+
+    use crate::file::save_package;
+
+    let saved_or_not = save_package("test_package".to_string(), &package_data.unwrap()[..]).await;
+    assert_eq!(saved_or_not.is_ok(), true);
+}
+
+#[test]
+async fn test_delete_package() {
+    use crate::request::download_package;
+
+    let package_data = download_package("test_package".to_owned()).await;
+    assert_eq!(package_data.is_some(), true);
+    assert_eq!(package_data.as_ref().unwrap().is_empty(), false);
+
+    use crate::file::save_package;
+
+    let saved_or_not = save_package("test_package".to_string(), &package_data.unwrap()[..]).await;
+    assert_eq!(saved_or_not.is_ok(), true);
+
+    use crate::file::delete_package;
+
+    let deleted_or_not = delete_package("test_package".to_string()).await;
+    assert_eq!(deleted_or_not.is_ok(), true);
 }