more functora-tagged tests

Author: functora

rust/functora-tagged/.gitignore

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

rust/functora-tagged/tests/infallible.rs

@@ -31,3 +31,37 @@ fn test_infallible_result_construction() {
     assert!(res.is_ok());
     assert_eq!(res.infallible(), "hello");
 }
+
+#[test]
+fn test_infallible_on_ok_result() {
+    let ok_result: Result<String, Infallible> =
+        Ok("test".to_string());
+    assert_eq!(ok_result.infallible(), "test");
+}
+
+#[test]
+fn test_infallible_direct_call_on_ok() {
+    let result: Result<i64, Infallible> = Ok(12345);
+
+    assert_eq!(result.infallible(), 12345);
+}
+
+#[test]
+fn test_infallible_trait_implementation() {
+    let value: i32 = 50;
+    let result: Result<i32, Infallible> = Ok(value);
+
+    assert_eq!(result.infallible(), value);
+}
+
+#[test]
+fn test_infallible_trait_definition_usage() {
+    fn requires_infallible_into<T: InfallibleInto<i32>>(
+        val: T,
+    ) -> i32 {
+        val.infallible()
+    }
+
+    let ok_result: Result<i32, Infallible> = Ok(200);
+    assert_eq!(requires_infallible_into(ok_result), 200);
+}

rust/functora-tagged/tests/integration.rs

@@ -2,8 +2,6 @@ use derive_more::Display;
 use functora_tagged::{
     InfallibleInto, ParseError, Refine, Tagged,
 };
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
 use std::collections::hash_map::DefaultHasher;
 use std::convert::Infallible;
 use std::error::Error;
@@ -225,65 +223,74 @@ fn test_tagged_deref() {
 }
 
 #[cfg(feature = "serde")]
-#[test]
-fn test_serde_user_id_roundtrip() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    struct Wrapper {
-        user_id: UserId,
+mod serde_tests {
+    use super::*;
+    use serde::{Deserialize, Serialize};
+
+    #[test]
+    fn test_serde_user_id_roundtrip() {
+        #[derive(
+            Serialize, Deserialize, PartialEq, Debug,
+        )]
+        struct Wrapper {
+            user_id: UserId,
+        }
+        let original = Wrapper {
+            user_id: "user_456".parse().unwrap(),
+        };
+        let toml = toml::to_string(&original).unwrap();
+        let deserialized: Wrapper =
+            toml::from_str(&toml).unwrap();
+        assert_eq!(original, deserialized);
+        assert_eq!(
+            deserialized.user_id.rep().rep(),
+            "user_456"
+        );
     }
-    let original = Wrapper {
-        user_id: "user_456".parse().unwrap(),
-    };
-    let toml = toml::to_string(&original).unwrap();
-    let deserialized: Wrapper =
-        toml::from_str(&toml).unwrap();
-    assert_eq!(original, deserialized);
-    assert_eq!(
-        deserialized.user_id.rep().rep(),
-        "user_456"
-    );
-}
 
-#[cfg(feature = "serde")]
-#[test]
-fn test_serde_user_id_invalid_refine() {
-    #[derive(Deserialize, Debug)]
-    struct Wrapper {
-        user_id: UserId,
+    #[test]
+    fn test_serde_user_id_invalid_refine() {
+        #[derive(Deserialize, Debug)]
+        struct Wrapper {
+            user_id: UserId,
+        }
+        let toml = r#"user_id = "bad""#;
+        let err =
+            toml::from_str::<Wrapper>(toml).unwrap_err();
+        assert!(
+            err.to_string().contains("UserIdError"),
+            "Unexpected failure: {err}"
+        );
+        let toml = r#"user_id = "user_123""#;
+        let wrapper: Wrapper =
+            toml::from_str(toml).unwrap();
+        assert_eq!(wrapper.user_id.rep().rep(), "user_123");
     }
-    let toml = r#"user_id = "bad""#;
-    let err = toml::from_str::<Wrapper>(toml).unwrap_err();
-    assert!(
-        err.to_string().contains("UserIdError"),
-        "Unexpected failure: {err}"
-    );
-    let toml = r#"user_id = "user_123""#;
-    let wrapper: Wrapper = toml::from_str(toml).unwrap();
-    assert_eq!(wrapper.user_id.rep().rep(), "user_123");
-}
 
-#[cfg(feature = "serde")]
-#[test]
-fn test_serde_email_roundtrip() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    struct Wrapper {
-        email: Email,
+    #[test]
+    fn test_serde_email_roundtrip() {
+        #[derive(
+            Serialize, Deserialize, PartialEq, Debug,
+        )]
+        struct Wrapper {
+            email: Email,
+        }
+        let original = Wrapper {
+            email: "[email protected]".parse().unwrap(),
+        };
+        let toml = toml::to_string(&original).unwrap();
+        let deserialized: Wrapper =
+            toml::from_str(&toml).unwrap();
+        assert_eq!(original, deserialized);
+        assert_eq!(
+            deserialized.email.rep().rep(),
+            "[email protected]"
+        );
     }
-    let original = Wrapper {
-        email: "[email protected]".parse().unwrap(),
-    };
-    let toml = toml::to_string(&original).unwrap();
-    let deserialized: Wrapper =
-        toml::from_str(&toml).unwrap();
-    assert_eq!(original, deserialized);
-    assert_eq!(
-        deserialized.email.rep().rep(),
-        "[email protected]"
-    );
 }
 
 #[cfg(feature = "diesel")]
-mod diesel_tests {
+mod diesel_integration_tests {
     use super::*;
     use diesel::insert_into;
     use diesel::prelude::*;