rust test coverage tool, more functora-tagged tests, ParseError source impl

Author: functora

rust/flake.nix

@@ -109,6 +109,7 @@
             bacon
             cargo
             cargo-edit
+            cargo-tarpaulin
             clippy
             rust-analyzer
             rustc

rust/functora-tagged/.gitignore

@@ -1 +1,2 @@
 /target
+tarpaulin-report.html

rust/functora-tagged/src/parse_error.rs

@@ -18,9 +18,15 @@ impl<Rep, Tag> Error for ParseError<Rep, Tag>
 where
     Rep: Debug + FromStr,
     Tag: Debug + Refine<Rep>,
-    Rep::Err: Debug + Display,
-    Tag::RefineError: Debug + Display,
+    Rep::Err: Error + Debug + Display + 'static,
+    Tag::RefineError: Error + Debug + Display + 'static,
 {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match self {
+            ParseError::Decode(e) => Some(e),
+            ParseError::Refine(e) => Some(e),
+        }
+    }
 }
 
 impl<Rep, Tag> Eq for ParseError<Rep, Tag>

rust/functora-tagged/tests/infallible.rs

@@ -6,3 +6,28 @@ fn test_infallible_into() {
     let result_ok: Result<i32, Infallible> = Ok(10);
     assert_eq!(result_ok.infallible(), 10);
 }
+
+#[test]
+fn test_infallible_explicit_call() {
+    let my_result: Result<u32, Infallible> = Ok(42);
+    assert_eq!(my_result.infallible(), 42);
+}
+
+#[test]
+fn test_infallible_trait_usage() {
+    fn takes_infallible_into<R: InfallibleInto<i32>>(
+        val: R,
+    ) -> i32 {
+        val.infallible()
+    }
+    let ok_result: Result<i32, Infallible> = Ok(100);
+    assert_eq!(takes_infallible_into(ok_result), 100);
+}
+
+#[test]
+fn test_infallible_result_construction() {
+    let res: Result<String, Infallible> =
+        Ok("hello".to_string());
+    assert!(res.is_ok());
+    assert_eq!(res.infallible(), "hello");
+}

rust/functora-tagged/tests/integration.rs

@@ -4,9 +4,11 @@ use functora_tagged::{
 };
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
+use std::collections::hash_map::DefaultHasher;
 use std::convert::Infallible;
 use std::error::Error;
 use std::fmt::Debug;
+use std::hash::{Hash, Hasher};
 
 #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Debug)]
 pub enum NonEmptyTag {}
@@ -177,6 +179,51 @@ fn test_upper_string_infallible() {
     assert_eq!(tagged.rep(), "TEST");
 }
 
+#[test]
+fn test_tagged_display() {
+    let tagged: NonEmpty<String> =
+        "display_test".parse().unwrap();
+    let display_str = format!("{}", tagged);
+    assert_eq!(display_str, "display_test");
+}
+
+#[test]
+fn test_tagged_hash() {
+    let tagged1: NonEmpty<String> =
+        "hash_test".parse().unwrap();
+    let tagged2: NonEmpty<String> =
+        "hash_test".parse().unwrap();
+    let tagged3: NonEmpty<String> =
+        "another_hash_test".parse().unwrap();
+
+    let mut hasher1 = DefaultHasher::new();
+    tagged1.hash(&mut hasher1);
+    let hash1 = hasher1.finish();
+
+    let mut hasher2 = DefaultHasher::new();
+    tagged2.hash(&mut hasher2);
+    let hash2 = hasher2.finish();
+
+    let mut hasher3 = DefaultHasher::new();
+    tagged3.hash(&mut hasher3);
+    let hash3 = hasher3.finish();
+
+    assert_eq!(hash1, hash2);
+    assert_ne!(hash1, hash3);
+}
+
+#[test]
+fn test_tagged_deref() {
+    let tagged: UpperString = UpperString::new(
+        "deref_test".into(),
+    )
+    .expect(
+        "This should not fail as Infallible cannot fail",
+    );
+    assert_eq!(tagged.to_uppercase(), "DEREF_TEST");
+    assert_eq!(tagged.len(), 10);
+}
+
 #[cfg(feature = "serde")]
 #[test]
 fn test_serde_user_id_roundtrip() {

rust/functora-tagged/tests/parse_error.rs

@@ -102,3 +102,69 @@ fn test_parse_error_eq() {
     assert_eq!(err_refine1, err_refine2);
     assert_ne!(err_decode1, err_refine1);
 }
+
+#[test]
+fn test_parse_error_error_trait() {
+    let decode_err = "abc".parse::<i32>().unwrap_err();
+    let parse_error_decode =
+        TestParseError::Decode(decode_err.clone());
+    if let Some(source_err) = parse_error_decode.source() {
+        if let Some(parsed_int_err) =
+            source_err
+                .downcast_ref::<std::num::ParseIntError>()
+        {
+            assert_eq!(parsed_int_err, &decode_err);
+        } else {
+            panic!("Source error was not a ParseIntError");
+        }
+    } else {
+        panic!("Source was None");
+    }
+
+    let refine_err = MyRefineError;
+    let parse_error_refine =
+        TestParseError::Refine(refine_err.clone());
+    if let Some(source_err) = parse_error_refine.source() {
+        if let Some(my_refine_err) =
+            source_err.downcast_ref::<MyRefineError>()
+        {
+            assert_eq!(my_refine_err, &refine_err);
+        } else {
+            panic!("Source error was not a MyRefineError");
+        }
+    } else {
+        panic!("Source was None");
+    }
+}
+
+#[test]
+fn test_parse_error_eq_trait() {
+    let decode_err1 = "abc".parse::<i32>().unwrap_err();
+    let refine_err1 = MyRefineError;
+
+    let err_decode1 =
+        TestParseError::Decode(decode_err1.clone());
+
+    let err_refine1 =
+        TestParseError::Refine(refine_err1.clone());
+
+    assert_eq!(err_decode1, err_decode1);
+    assert_eq!(err_refine1, err_refine1);
+
+    assert_ne!(err_decode1, err_refine1);
+}
+
+#[test]
+fn test_parse_error_clone_variants() {
+    let decode_err = "abc".parse::<i32>().unwrap_err();
+    let parse_error_decode =
+        TestParseError::Decode(decode_err.clone());
+    let cloned_decode = parse_error_decode.clone();
+    assert_eq!(parse_error_decode, cloned_decode);
+
+    let refine_err = MyRefineError;
+    let parse_error_refine =
+        TestParseError::Refine(refine_err.clone());
+    let cloned_refine = parse_error_refine.clone();
+    assert_eq!(parse_error_refine, cloned_refine);
+}

rust/functora-tagged/tests/refine.rs

@@ -22,7 +22,7 @@ impl Refine<String> for MyTag {
 }
 
 #[test]
-fn test_refine_default_implementation() {
+fn test_refine_my_tag_implementation() {
     let rep_value = String::from("test_string");
     let refined_rep = MyTag::refine(rep_value.clone());
 
@@ -50,7 +50,7 @@ impl Refine<String> for StrictTag {
 }
 
 #[test]
-fn test_refine_custom_implementation() {
+fn test_refine_strict_tag_implementation() {
     let strict_value = String::from("strict_value");
     let refined_strict =
         StrictTag::refine(strict_value.clone());
@@ -69,3 +69,21 @@ fn test_refine_custom_implementation() {
         )
     );
 }
+
+#[derive(Debug)]
+struct DefaultRefineTag;
+
+impl Refine<String> for DefaultRefineTag {
+    type RefineError = String;
+}
+
+#[test]
+fn test_refine_default_implementation() {
+    let rep_value = String::from("test_default_refine");
+
+    let refined_rep =
+        DefaultRefineTag::refine(rep_value.clone());
+
+    assert!(refined_rep.is_ok());
+    assert_eq!(refined_rep.unwrap(), rep_value);
+}