[wip] unit testing

- refactored mock impl for IDs

src/test_util/mock_client.rs

@@ -1,26 +1,27 @@
 use crate::{
-    file,
+    Result, file,
-    sharry::{self, AliasID, FileID, ShareID, Uri},
+    sharry::{AliasID, Client, FileID, ShareID, Uri, json},
-    test_util::mock_ids,
 };
 
+use super::mock_ids::CheckID;
+
 pub struct MockClient;
 
-impl sharry::Client for MockClient {
+impl Client for MockClient {
     fn share_create(
         &self,
         uri: &Uri,
         alias_id: &AliasID,
-        _: sharry::json::NewShareRequest,
+        _: json::NewShareRequest,
-    ) -> crate::Result<ShareID> {
+    ) -> Result<ShareID> {
-        mock_ids::check_alias(uri, alias_id)?;
+        (uri, alias_id).check()?;
 
         Ok(true.into())
     }
 
     fn share_notify(&self, uri: &Uri, alias_id: &AliasID, share_id: &ShareID) -> crate::Result<()> {
-        mock_ids::check_alias(uri, alias_id)?;
+        (uri, alias_id).check()?;
-        mock_ids::check_share(share_id)?;
+        share_id.check()?;
 
         Ok(())
     }
@@ -31,9 +32,9 @@ impl sharry::Client for MockClient {
         alias_id: &AliasID,
         share_id: &ShareID,
         _: &file::Checked,
-    ) -> crate::Result<FileID> {
+    ) -> Result<FileID> {
-        mock_ids::check_alias(uri, alias_id)?;
+        (uri, alias_id).check()?;
-        mock_ids::check_share(share_id)?;
+        share_id.check()?;
 
         Ok(true.into())
     }
@@ -44,9 +45,9 @@ impl sharry::Client for MockClient {
         alias_id: &AliasID,
         share_id: &ShareID,
         chunk: &file::Chunk,
-    ) -> crate::Result<()> {
+    ) -> Result<()> {
-        mock_ids::check_alias(uri, alias_id)?;
+        (uri, alias_id).check()?;
-        mock_ids::check_file(share_id, chunk.get_file_id())?;
+        (share_id, chunk.get_file_id()).check()?;
 
         // TODO: `chunk` must align to a full MiB
 

src/test_util/mock_ids.rs

@@ -1,43 +1,48 @@
-use crate::sharry::{AliasID, FileID, ShareID, Uri};
+use crate::{
+    Result,
+    sharry::{AliasID, FileID, ShareID, Uri},
+};
 
 const VALID_URI: &'static str = "scheme://valid.uri";
 const VALID_ALIAS: &'static str = "valid-alias";
 const VALID_SHARE: &'static str = "valid-share";
 const VALID_FILE: &'static str = "valid-file";
 
-pub fn check_uri(uri: &Uri) -> crate::Result<&Uri> {
+pub trait CheckID {
-    if uri.to_string() != VALID_URI {
+    fn check(self) -> Result<()>;
-        Err(uri.into())
+}
-    } else {
+
-        Ok(uri)
+impl CheckID for (&Uri, &AliasID) {
+    fn check(self) -> Result<()> {
+        if self.0.to_string() != VALID_URI {
+            Err(self.0.into())
+        } else if self.1.as_ref() != VALID_ALIAS {
+            Err(self.1.into())
+        } else {
+            Ok(())
+        }
     }
 }
 
-pub fn check_alias<'t>(uri: &Uri, alias_id: &'t AliasID) -> crate::Result<&'t AliasID> {
+impl CheckID for &ShareID {
-    check_uri(uri)?;
+    fn check(self) -> Result<()> {
-
+        if self.to_string() != VALID_SHARE {
-    if alias_id.as_ref() != VALID_ALIAS {
+            Err(self.into())
-        Err(alias_id.into())
+        } else {
-    } else {
+            Ok(())
-        Ok(alias_id)
+        }
     }
 }
 
-pub fn check_share(share_id: &ShareID) -> crate::Result<&ShareID> {
+impl CheckID for (&ShareID, &FileID) {
-    if share_id.to_string() != VALID_SHARE {
+    fn check(self) -> Result<()> {
-        Err(share_id.into())
+        self.0.check()?;
-    } else {
-        Ok(share_id)
-    }
-}
 
-pub fn check_file<'t>(share_id: &ShareID, file_id: &'t FileID) -> crate::Result<&'t FileID> {
+        if self.1.to_string() != VALID_FILE {
-    check_share(share_id)?;
+            Err(self.1.into())
-
+        } else {
-    if file_id.to_string() != VALID_FILE {
+            Ok(())
-        Err(file_id.into())
+        }
-    } else {
-        Ok(file_id)
     }
 }
 
@@ -92,41 +97,54 @@ mod tests {
 
     #[test]
     fn true_makes_valids() {
-        assert!(check_uri(&true.into()).is_ok());
+        let uri = Uri::from(true);
-        assert!(check_alias(&true.into(), &true.into()).is_ok());
+        let alias_id = AliasID::from(true);
-        assert!(check_share(&true.into()).is_ok());
+        let share_id = ShareID::from(true);
-        assert!(check_file(&true.into(), &true.into()).is_ok());
+        let file_id = FileID::from(true);
+
+        assert!(matches!((&uri, &alias_id).check(), Ok(())));
+        assert!(matches!(share_id.check(), Ok(())));
+        assert!(matches!((&share_id, &file_id).check(), Ok(())));
     }
 
     #[test]
     fn false_makes_invalids() {
-        // invalid Uri
+        let uri = Uri::from(true);
-        let check = check_uri(&false.into()).expect_err("should be invalid");
+        let alias_id = AliasID::from(true);
-        let p = check.get_invalid_param().expect("should be InvalidParam");
+        let share_id = ShareID::from(true);
-        assert!(matches!(p, Parameter::Uri(_)));
+        let file_id = FileID::from(true);
+
+        let uri_i = Uri::from(false);
+        let alias_id_i = AliasID::from(false);
+        let share_id_i = ShareID::from(false);
+        let file_id_i = FileID::from(false);
 
         // invalid Uri, valid alias
-        let check = check_alias(&false.into(), &true.into()).expect_err("should be invalid");
+        let check = (&uri_i, &alias_id).check().expect_err("should be invalid");
         let p = check.get_invalid_param().expect("should be InvalidParam");
         assert!(matches!(p, Parameter::Uri(_)));
 
         // valid Uri, invalid alias
-        let check = check_alias(&true.into(), &false.into()).expect_err("should be invalid");
+        let check = (&uri, &alias_id_i).check().expect_err("should be invalid");
         let p = check.get_invalid_param().expect("should be InvalidParam");
         assert!(matches!(p, Parameter::AliasID(_)));
 
         // invalid share
-        let check = check_share(&false.into()).expect_err("should be invalid");
+        let check = share_id_i.check().expect_err("should be invalid");
         let p = check.get_invalid_param().expect("should be InvalidParam");
         assert!(matches!(p, Parameter::ShareID(_)));
 
         // invalid share, valid file
-        let check = check_file(&false.into(), &true.into()).expect_err("should be invalid");
+        let check = (&share_id_i, &file_id)
+            .check()
+            .expect_err("should be invalid");
         let p = check.get_invalid_param().expect("should be InvalidParam");
         assert!(matches!(p, Parameter::ShareID(_)));
 
         // valid share, invalid file
-        let check = check_file(&true.into(), &false.into()).expect_err("should be invalid");
+        let check = (&share_id, &file_id_i)
+            .check()
+            .expect_err("should be invalid");
         let p = check.get_invalid_param().expect("should be InvalidParam");
         assert!(matches!(p, Parameter::FileID(_)));
     }