[wip] unit tests

- strip unneeded mod `test_util::mock_ids::tests`
- coverage for `sharry::uri`

src/sharry/uri.rs

@@ -28,7 +28,7 @@ impl AsRef<[u8]> for Uri {
 
 fn captured(caps: &Captures, name: &str) -> String {
     caps.name(name)
-        .unwrap_or_else(|| panic!("{name} not captured"))
+        .unwrap_or_else(|| panic!("{name:?} not captured"))
         .as_str()
         .to_string()
 }
@@ -103,6 +103,36 @@ mod tests {
         test_util::check_trait,
     };
 
+    #[test]
+    fn check_captured_works() {
+        let cases = [
+            // simple http host
+            ("http://example.com", "http", "example.com"),
+            // https host with port
+            ("https://my-host:8080", "https", "my-host:8080"),
+            // trailing slash
+            ("scheme://host/", "scheme", "host"),
+            // with path
+            ("scheme://host/path/to/whatever", "scheme", "host"),
+            // custom scheme
+            ("custom+scheme://host", "custom+scheme", "host"),
+        ];
+
+        for (good, scheme, host) in cases {
+            let caps = SHARRY_URI_RE.captures(good).unwrap();
+
+            assert_eq!(captured(&caps, "scheme"), scheme);
+            assert_eq!(captured(&caps, "host"), host);
+        }
+    }
+
+    #[test]
+    #[should_panic = "\"foo\" not captured"]
+    fn make_captured_panic() {
+        let caps = SHARRY_URI_RE.captures("http://example.com").unwrap();
+        captured(&caps, "foo");
+    }
+
     #[test]
     fn basic_traits_working() {
         let cases = [

src/test_util/mock_ids.rs

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