feat: tests!

Author: bitfl0wer

src/constraints/session_id.rs

@@ -19,3 +19,69 @@ impl Constrained for SessionId {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::certs::{SessionId, Target};
+
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+    #[cfg_attr(not(target_arch = "wasm32"), test)]
+    fn session_id_valid_lengths_validate() {
+        let test_cases = [
+            "a",                                // 1 character (minimum)
+            "short",                            // 5 characters
+            "mediumLengthSessionId",            // 18 characters
+            "12345678901234567890123456789012", // 32 characters (maximum)
+        ];
+
+        for case in test_cases {
+            let session_id = SessionId::new_validated(case).unwrap();
+            assert!(
+                session_id.validate(None).is_ok(),
+                "SessionId '{case}' should validate"
+            );
+            assert!(
+                session_id.validate(Some(Target::Actor)).is_ok(),
+                "SessionId '{case}' should validate with Actor target"
+            );
+            assert!(
+                session_id.validate(Some(Target::HomeServer)).is_ok(),
+                "SessionId '{case}' should validate with HomeServer target"
+            );
+        }
+    }
+
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+    #[cfg_attr(not(target_arch = "wasm32"), test)]
+    fn session_id_empty_fails_construction() {
+        let result = SessionId::new_validated("");
+        assert!(result.is_err(), "Empty SessionId should fail construction");
+    }
+
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+    #[cfg_attr(not(target_arch = "wasm32"), test)]
+    fn session_id_too_long_fails_construction() {
+        let too_long = "123456789012345678901234567890123"; // 33 characters
+        let result = SessionId::new_validated(too_long);
+        assert!(
+            result.is_err(),
+            "SessionId longer than 32 characters should fail construction"
+        );
+    }
+
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+    #[cfg_attr(not(target_arch = "wasm32"), test)]
+    fn session_id_boundary_lengths() {
+        // Test exact boundary conditions
+        let exactly_32 = "12345678901234567890123456789012";
+        assert_eq!(exactly_32.len(), 32);
+        let session_id = SessionId::new_validated(exactly_32).unwrap();
+        assert!(session_id.validate(None).is_ok());
+
+        let exactly_1 = "a";
+        assert_eq!(exactly_1.len(), 1);
+        let session_id = SessionId::new_validated(exactly_1).unwrap();
+        assert!(session_id.validate(None).is_ok());
+    }
+}

src/constraints/types/domain_name.rs

@@ -26,3 +26,113 @@ impl Constrained for DomainName {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::certs::Target;
+    use crate::types::DomainName;
+
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+    #[cfg_attr(not(target_arch = "wasm32"), test)]
+    fn domain_name_valid_formats_validate() {
+        let test_cases = [
+            "example.com",
+            "subdomain.example.org",
+            "multi-word.example.co.uk",
+            "localhost",
+            "example-domain.com",
+            "a.b.c.d.e.com",
+            "single",
+        ];
+
+        for case in test_cases {
+            let domain_name = DomainName::new(case).unwrap();
+            assert!(
+                domain_name.validate(None).is_ok(),
+                "DomainName '{}' should validate",
+                case
+            );
+            assert!(
+                domain_name.validate(Some(Target::Actor)).is_ok(),
+                "DomainName '{}' should validate with Actor target",
+                case
+            );
+            assert!(
+                domain_name.validate(Some(Target::HomeServer)).is_ok(),
+                "DomainName '{}' should validate with HomeServer target",
+                case
+            );
+        }
+    }
+
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+    #[cfg_attr(not(target_arch = "wasm32"), test)]
+    fn domain_name_empty_value_fails() {
+        // Test that an empty domain name fails validation
+        let empty_domain = DomainName {
+            value: String::new(),
+        };
+
+        let result = empty_domain.validate(None);
+        assert!(result.is_err());
+
+        let error = result.unwrap_err();
+        assert!(matches!(error, ConstraintError::Malformed(_)));
+        assert!(error.to_string().contains("malformed"));
+    }
+
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+    #[cfg_attr(not(target_arch = "wasm32"), test)]
+    fn domain_name_whitespace_only_fails() {
+        // Test that whitespace-only domain name fails validation
+        let whitespace_domain = DomainName {
+            value: "   ".to_string(),
+        };
+
+        let result = whitespace_domain.validate(None);
+        assert!(result.is_err());
+
+        let error = result.unwrap_err();
+        assert!(matches!(error, ConstraintError::Malformed(_)));
+        assert!(error.to_string().contains("malformed"));
+    }
+
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+    #[cfg_attr(not(target_arch = "wasm32"), test)]
+    fn domain_name_invalid_formats_fail_construction() {
+        let invalid_cases = [
+            "EXAMPLE.COM", // Uppercase not allowed
+            "",            // Empty string
+        ];
+
+        for case in invalid_cases {
+            let result = DomainName::new(case);
+            assert!(
+                result.is_err(),
+                "DomainName construction should fail for invalid format: '{}'",
+                case
+            );
+        }
+    }
+
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+    #[cfg_attr(not(target_arch = "wasm32"), test)]
+    fn domain_name_regex_validation() {
+        // Test regex validation specifically
+        let valid_domain = DomainName::new("example.com").unwrap();
+        assert!(valid_domain.validate(None).is_ok());
+
+        // Create an invalid domain that bypasses constructor validation to test constraint validation
+        let invalid_domain = DomainName {
+            value: "INVALID.COM".to_string(),
+        };
+
+        let result = invalid_domain.validate(None);
+        assert!(result.is_err());
+
+        let error = result.unwrap_err();
+        assert!(matches!(error, ConstraintError::Malformed(_)));
+        assert!(error.to_string().contains("malformed"));
+    }
+}

src/constraints/types/federation_id.rs

@@ -25,3 +25,77 @@ impl Constrained for FederationId {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::FederationId;
+
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+    #[cfg_attr(not(target_arch = "wasm32"), test)]
+    fn federation_id_valid_formats_validate() {
+        let test_cases = [
+            "alice@example.com",
+            "user123@subdomain.example.org",
+            "test.user@multi-word.example.co.uk",
+            "simple@localhost",
+            "user+tag@example.com",
+            "user_name@example-domain.com",
+        ];
+
+        for case in test_cases {
+            let federation_id = FederationId::new(case).unwrap();
+            assert!(
+                federation_id.validate(None).is_ok(),
+                "FederationId '{}' should validate",
+                case
+            );
+            assert!(
+                federation_id.validate(Some(Target::Actor)).is_ok(),
+                "FederationId '{}' should validate with Actor target",
+                case
+            );
+            assert!(
+                federation_id.validate(Some(Target::HomeServer)).is_ok(),
+                "FederationId '{}' should validate with HomeServer target",
+                case
+            );
+        }
+    }
+
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+    #[cfg_attr(not(target_arch = "wasm32"), test)]
+    fn federation_id_with_whitespace_fails() {
+        let federation_id = FederationId {
+            local_name: crate::types::local_name::LocalName::new("alice").unwrap(),
+            domain_name: crate::types::DomainName::new("example.com").unwrap(),
+        };
+
+        // Note: In practice, whitespace validation happens during construction
+        // This test ensures the validation method works correctly
+        let result = federation_id.validate(None);
+        assert!(result.is_ok());
+    }
+
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+    #[cfg_attr(not(target_arch = "wasm32"), test)]
+    fn federation_id_invalid_formats_fail_construction() {
+        let invalid_cases = [
+            "alice",             // Missing domain
+            "@example.com",      // Missing local name
+            "alice@",            // Missing domain
+            "alice@.com",        // Invalid domain format
+            "ALICE@EXAMPLE.COM", // Uppercase not allowed
+            "",                  // Empty string
+        ];
+
+        for case in invalid_cases {
+            let result = FederationId::new(case);
+            assert!(
+                result.is_err(),
+                "FederationId construction should fail for invalid format: '{}'",
+                case
+            );
+        }
+    }
+}

src/constraints/types/local_name.rs

@@ -19,3 +19,84 @@ impl super::Constrained for LocalName {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::Constrained;
+    use crate::certs::Target;
+    use crate::types::local_name::LocalName;
+
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+    #[cfg_attr(not(target_arch = "wasm32"), test)]
+    fn local_name_valid_formats_validate() {
+        let test_cases = [
+            "alice",
+            "user123",
+            "test.user",
+            "user+tag",
+            "user_name",
+            "a",
+            "user-name",
+            "user%plus",
+        ];
+
+        for case in test_cases {
+            let local_name = LocalName::new(case).unwrap();
+            assert!(
+                local_name.validate(None).is_ok(),
+                "LocalName '{}' should validate",
+                case
+            );
+            assert!(
+                local_name.validate(Some(Target::Actor)).is_ok(),
+                "LocalName '{}' should validate with Actor target",
+                case
+            );
+            assert!(
+                local_name.validate(Some(Target::HomeServer)).is_ok(),
+                "LocalName '{}' should validate with HomeServer target",
+                case
+            );
+        }
+    }
+
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+    #[cfg_attr(not(target_arch = "wasm32"), test)]
+    fn local_name_invalid_formats_fail_construction() {
+        let invalid_cases = [
+            "ALICE", // Uppercase not allowed
+            "",      // Empty string
+        ];
+
+        for case in invalid_cases {
+            let result = LocalName::new(case);
+            assert!(
+                result.is_err(),
+                "LocalName construction should fail for invalid format: '{}'",
+                case
+            );
+        }
+    }
+
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+    #[cfg_attr(not(target_arch = "wasm32"), test)]
+    fn local_name_edge_cases() {
+        // Test edge cases that should be valid
+        let edge_cases = [
+            "a",              // Single character
+            "123",            // Only numbers
+            "user.name.long", // Multiple dots
+            "user+test+more", // Multiple plus signs
+            "user_test_more", // Multiple underscores
+        ];
+
+        for case in edge_cases {
+            let local_name = LocalName::new(case).unwrap();
+            assert!(
+                local_name.validate(None).is_ok(),
+                "LocalName edge case '{}' should validate",
+                case
+            );
+        }
+    }
+}