update parsing logic and add tests

amnet-server/src/utils.rs

@@ -41,25 +41,117 @@ pub (crate) fn parse_idm_hex(idm_hex: &String) -> Option<[u8; 8]> {
     Some(idm_bytes)
 }
 
-pub (crate) fn is_valid_access_code(code: &String) -> bool {
-    if code.len() > 20 {
-        return false;
-    }
+#[cfg(test)]
+mod tests {
+    use super::*;
 
-    let cleaned_code: String = code.chars().filter(|c| !c.is_whitespace()).collect();
+    mod format_hex_bytes_tests {
+        use super::*;
 
-    if cleaned_code.len() != 20 {
-        return false;
-    }
-
-    let mut seen_non_zero = false;
-    let is_all_digits = cleaned_code.chars().all(|c| {
-        if c != '0' {
-            seen_non_zero = true;
+        #[test]
+        fn formats_empty_bytes() {
+            assert_eq!(format_hex_bytes(&[]), "");
         }
 
-        c.is_ascii_digit()
-    });
+        #[test]
+        fn formats_access_code_bytes() {
+            let bytes = [0x00, 0x10, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56];
+            assert_eq!(format_hex_bytes(&bytes), "0010 1234 5678 9012 3456");
+        }
+    }
 
-    is_all_digits && seen_non_zero
+    mod parse_access_code_tests {
+        use super::*;
+
+        #[test]
+        fn parses_full_20_digit_code() {
+            let code = "00101234567890123456".to_string();
+            let result = parse_access_code(&code);
+            
+            assert!(result.is_some());
+            assert_eq!(result.unwrap(), [0x00, 0x10, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]);
+        }
+
+        #[test]
+        fn parses_code_with_spaces() {
+            let code = "0010 1234 5678 9012 3456".to_string();
+            let result = parse_access_code(&code);
+
+            assert!(result.is_some());
+            assert_eq!(result.unwrap(), [0x00, 0x10, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]);
+        }
+
+        #[test]
+        fn parses_code_with_leading_zeros() {
+            let code = "00000000000000001234".to_string(); // Valid 20-digit code with leading zeros
+            let result = parse_access_code(&code);
+
+            assert!(result.is_some());
+            assert_eq!(result.unwrap(), [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x34]);
+        }
+
+        #[test]
+        fn returns_none_for_invalid_hex() {
+            let code = "GHIJKLMNOPQRSTUVWXYZ".to_string();
+            let result = parse_access_code(&code);
+
+            assert!(result.is_none());
+        }
+
+        #[test]
+        fn parses_code_with_all_zeros() {
+            let code = "00000000000000000000".to_string();
+            let result = parse_access_code(&code);
+
+            assert!(result.is_some());
+            assert_eq!(result.unwrap(), [0x00; 10]);
+        }
+    }
+
+    mod parse_idm_hex_tests {
+        use super::*;
+
+        #[test]
+        fn parses_full_16_char_idm() {
+            let idm = "0102030405060708".to_string();
+            let result = parse_idm_hex(&idm);
+
+            assert!(result.is_some());
+            assert_eq!(result.unwrap(), [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]);
+        }
+
+        #[test]
+        fn parses_short_idm_returns_none() {
+            let idm = "1234".to_string();
+            let result = parse_idm_hex(&idm);
+
+            // IDm is too short - should fail
+            assert!(result.is_none());
+        }
+
+        #[test]
+        fn returns_none_for_too_long_idm() {
+            let idm = "01020304050607080910".to_string(); // 20 chars
+            let result = parse_idm_hex(&idm);
+
+            assert!(result.is_none());
+        }
+
+        #[test]
+        fn returns_none_for_non_hex_characters() {
+            let idm = "0102GHIJ".to_string();
+            let result = parse_idm_hex(&idm);
+
+            assert!(result.is_none());
+        }
+
+        #[test]
+        fn parses_empty_idm_returns_none() {
+            let idm = "".to_string();
+            let result = parse_idm_hex(&idm);
+
+            // Empty IDm should fail
+            assert!(result.is_none());
+        }
+    }
 }