[wip] unit tests for mock_client module

- re-added redundant `tests` submodules for good form

src/test_util/mock_client.rs

@@ -21,7 +21,7 @@ struct MockShare {
     files: HashMap<String, MockFile>,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 struct MockFile {
     size: u64,
     offset: u64,
@@ -164,24 +164,177 @@ impl Client for MockClient {
     }
 }
 
-#[test]
-fn insert_share_works() {
+// technically redundant, but kept for refactoring purposes
+#[cfg(test)]
+mod tests {
     use std::collections::HashSet;
 
-    let client = MockClient::default();
-    let share_ids: [_; 8] = std::array::from_fn(|_| ShareID::from(true));
+    use super::*;
 
-    for share_id in share_ids.as_ref() {
-        assert!(client.insert_share(share_id, MockShare::default()).is_ok());
+    fn check_tostr_eq<L, R>(left: L, right: R)
+    where
+        L: ExactSizeIterator,
+        L::Item: ToString,
+        R: ExactSizeIterator,
+        R::Item: ToString,
+    {
+        assert_eq!(left.len(), right.len());
+
+        let l_strings: HashSet<_> = left.map(|s| s.to_string()).collect();
+        let r_strings: HashSet<_> = right.map(|s| s.to_string()).collect();
+
+        assert_eq!(l_strings, r_strings);
     }
 
-    assert_eq!(client.shares.borrow().len(), share_ids.len());
+    fn add_share(client: &MockClient) -> ShareID {
+        let share_id = ShareID::from(true);
+        client
+            .insert_share(&share_id, MockShare::default())
+            .unwrap();
 
-    let sid_strings: HashSet<_> = share_ids.iter().map(ToString::to_string).collect();
-    let cli_strings: HashSet<_> = (client.shares.borrow())
-        .keys()
-        .map(ToString::to_string)
-        .collect();
+        share_id
+    }
 
-    assert_eq!(sid_strings, cli_strings);
+    fn add_file(client: &MockClient, share_id: &ShareID) -> FileID {
+        let file_id = FileID::from(true);
+        client
+            .insert_file(share_id, &file_id, MockFile::default())
+            .unwrap();
+
+        file_id
+    }
+
+    #[test]
+    fn insert_share_works() {
+        let client = MockClient::default();
+        let share_ids: [_; 10] = std::array::from_fn(|_| ShareID::from(true));
+
+        for share_id in share_ids.as_ref() {
+            assert!(client.insert_share(share_id, MockShare::default()).is_ok());
+        }
+
+        check_tostr_eq(client.shares.borrow().keys(), share_ids.iter());
+    }
+
+    #[test]
+    fn insert_share_double_errors() {
+        let client = MockClient::default();
+        let share_ids: [_; 10] = std::array::from_fn(|_| add_share(&client));
+
+        for share_id in share_ids.as_ref() {
+            let res = client.insert_share(&share_id, MockShare::default());
+            assert!(res.is_err());
+            assert!(
+                matches!(res.unwrap_err(), Error::Response(s) if s.contains("can't insert share"))
+            );
+        }
+    }
+
+    #[test]
+    fn get_share_works() {
+        let client = MockClient::default();
+        let share_ids: [_; 10] = std::array::from_fn(|_| add_share(&client));
+
+        for share_id in share_ids.as_ref() {
+            assert!(client.get_share(share_id).is_ok());
+        }
+    }
+
+    #[test]
+    fn get_share_nex_errors() {
+        let client = MockClient::default();
+        add_share(&client);
+        let share_ids_nex: [_; 10] = std::array::from_fn(|_| ShareID::from(true));
+
+        for share_id_nex in share_ids_nex.as_ref() {
+            let res = client.get_share(share_id_nex);
+
+            assert!(res.is_err());
+            assert!(
+                matches!(res.unwrap_err(), Error::Response(s) if s.contains("can't find share"))
+            );
+        }
+    }
+
+    #[test]
+    fn insert_file_works() {
+        let client = MockClient::default();
+        let share_id = add_share(&client);
+        let file_ids: [_; 10] = std::array::from_fn(|_| FileID::from(true));
+
+        for file_id in file_ids.as_ref() {
+            assert!(
+                client
+                    .insert_file(&share_id, file_id, MockFile::default())
+                    .is_ok()
+            );
+        }
+
+        let shares = client.shares.borrow();
+        let share = shares.get(&share_id.to_string()).unwrap();
+
+        check_tostr_eq(share.files.keys(), file_ids.iter());
+    }
+
+    #[test]
+    fn insert_file_nex_share_errors() {
+        let client = MockClient::default();
+        add_share(&client);
+
+        let share_id_nex = ShareID::default();
+        let res = client.insert_file(&share_id_nex, &FileID::from(true), MockFile::default());
+        assert!(res.is_err());
+        assert!(matches!(res.unwrap_err(), Error::Response(s) if s.contains("can't find share")));
+    }
+
+    #[test]
+    fn insert_file_double_errors() {
+        let client = MockClient::default();
+        let share_id = add_share(&client);
+        let file_ids: [_; 10] = std::array::from_fn(|_| add_file(&client, &share_id));
+
+        for file_id in file_ids.as_ref() {
+            let res = client.insert_file(&share_id, &file_id, MockFile::default());
+            assert!(res.is_err());
+            assert!(
+                matches!(res.unwrap_err(), Error::Response(s) if s.contains("can't insert file"))
+            );
+        }
+    }
+
+    #[test]
+    fn get_file_works() {
+        let client = MockClient::default();
+        let share_id = add_share(&client);
+        let file_ids: [_; 10] = std::array::from_fn(|_| add_file(&client, &share_id));
+
+        for file_id in file_ids.as_ref() {
+            assert!(client.get_file(&share_id, file_id).is_ok());
+        }
+    }
+
+    #[test]
+    fn get_file_nex_errors() {
+        let client = MockClient::default();
+        let share_id = add_share(&client);
+        add_file(&client, &share_id);
+        let file_ids_nex: [_; 10] = std::array::from_fn(|_| FileID::from(true));
+
+        for file_id_nex in file_ids_nex.as_ref() {
+            let share_id_nex = ShareID::from(true);
+            let res = client.get_file(&share_id_nex, file_id_nex);
+
+            assert!(res.is_err());
+            assert!(
+                matches!(res.unwrap_err(), Error::Response(s) if s.contains("can't find share"))
+            );
+
+            let res = client.get_file(&share_id, file_id_nex);
+
+            assert!(res.is_err());
+            assert!(
+                matches!(res.unwrap_err(), Error::Response(s) if s.contains("can't find file"))
+            );
+        }
+    }
 }

src/test_util/mock_ids.rs

@@ -109,68 +109,74 @@ impl From<bool> for FileID {
     }
 }
 
-#[test]
-fn true_makes_valids() {
-    let uri = Uri::from(true);
-    let alias_id = AliasID::from(true);
-    let share_id = ShareID::from(true);
-    let file_id = FileID::from(true);
+// technically redundant, but kept for refactoring purposes
+#[cfg(test)]
+mod tests {
+    use super::*;
 
-    assert!((&uri, &alias_id).check().is_ok());
-    assert!(share_id.check().is_ok());
-    assert!((&share_id, &file_id).check().is_ok());
-}
+    #[test]
+    fn true_makes_valids() {
+        let uri = Uri::from(true);
+        let alias_id = AliasID::from(true);
+        let share_id = ShareID::from(true);
+        let file_id = FileID::from(true);
 
-#[test]
-fn default_is_valid() {
-    let uri = Uri::default();
-    let alias_id = AliasID::from(true); // no `impl Default`
-    let share_id = ShareID::default();
-    let file_id = FileID::default();
-
-    assert!((&uri, &alias_id).check().is_ok());
-    assert!(share_id.check().is_ok());
-    assert!((&share_id, &file_id).check().is_ok());
-}
-
-#[test]
-fn false_makes_invalids() {
-    use crate::Parameter;
-
-    fn test_check(value: impl CheckID, callback: impl FnOnce(&Parameter) -> bool) {
-        let check = value.check().unwrap_err();
-        let p = check.get_invalid_param().unwrap();
-        assert!(callback(p));
+        assert!((&uri, &alias_id).check().is_ok());
+        assert!(share_id.check().is_ok());
+        assert!((&share_id, &file_id).check().is_ok());
     }
 
-    // valid ids
-    let uri = Uri::from(true);
-    let alias_id = AliasID::from(true);
-    let share_id = ShareID::from(true);
-    let file_id = FileID::from(true);
+    #[test]
+    fn default_is_valid() {
+        let uri = Uri::default();
+        let alias_id = AliasID::from(true); // no `impl Default`
+        let share_id = ShareID::default();
+        let file_id = FileID::default();
 
-    // invalid ids
-    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);
+        assert!((&uri, &alias_id).check().is_ok());
+        assert!(share_id.check().is_ok());
+        assert!((&share_id, &file_id).check().is_ok());
+    }
 
-    // param checks
-    let is_uri_i = |p: &Parameter| matches!(p, Parameter::Uri(_));
-    let is_alias_id_i = |p: &Parameter| matches!(p, Parameter::AliasID(_));
-    let is_share_id_i = |p: &Parameter| matches!(p, Parameter::ShareID(_));
-    let is_file_id_i = |p: &Parameter| matches!(p, Parameter::FileID(_));
+    #[test]
+    fn false_makes_invalids() {
+        use crate::Parameter;
 
-    // uri + alias
-    test_check((&uri_i, &alias_id_i), is_uri_i);
-    test_check((&uri_i, &alias_id), is_uri_i);
-    test_check((&uri, &alias_id_i), is_alias_id_i);
+        fn test_check(value: impl CheckID, callback: impl FnOnce(&Parameter) -> bool) {
+            let check = value.check().unwrap_err();
+            let p = check.get_invalid_param().unwrap();
+            assert!(callback(p));
+        }
 
-    // share
-    test_check(&share_id_i, is_share_id_i);
+        // valid ids
+        let uri = Uri::from(true);
+        let alias_id = AliasID::from(true);
+        let share_id = ShareID::from(true);
+        let file_id = FileID::from(true);
 
-    // share + file
-    test_check((&share_id_i, &file_id_i), is_share_id_i);
-    test_check((&share_id_i, &file_id), is_share_id_i);
-    test_check((&share_id, &file_id_i), is_file_id_i);
+        // invalid ids
+        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);
+
+        // param checks
+        let is_uri_i = |p: &Parameter| matches!(p, Parameter::Uri(_));
+        let is_alias_id_i = |p: &Parameter| matches!(p, Parameter::AliasID(_));
+        let is_share_id_i = |p: &Parameter| matches!(p, Parameter::ShareID(_));
+        let is_file_id_i = |p: &Parameter| matches!(p, Parameter::FileID(_));
+
+        // uri + alias
+        test_check((&uri_i, &alias_id_i), is_uri_i);
+        test_check((&uri_i, &alias_id), is_uri_i);
+        test_check((&uri, &alias_id_i), is_alias_id_i);
+
+        // share
+        test_check(&share_id_i, is_share_id_i);
+
+        // share + file
+        test_check((&share_id_i, &file_id_i), is_share_id_i);
+        test_check((&share_id_i, &file_id), is_share_id_i);
+        test_check((&share_id, &file_id_i), is_file_id_i);
+    }
 }

src/test_util/mod.rs

@@ -29,8 +29,14 @@ pub fn create_file(data: &[u8]) -> NamedTempFile {
     tmp
 }
 
-#[test]
-#[should_panic = "`impl foo for bar` expected: 1, actual: 0"]
-fn make_check_trait_panic() {
-    check_trait(0, 1, "foo", "bar");
+// technically redundant, but kept for refactoring purposes
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    #[should_panic = "`impl foo for bar` expected: 1, actual: 0"]
+    fn make_check_trait_panic() {
+        check_trait(0, 1, "foo", "bar");
+    }
 }