refactored the error enum, added module to handle verification functions, implemented decode for ushort

Author: simplist-coder

amqp-type/src/error.rs

@@ -4,6 +4,8 @@ use thiserror::Error;
 pub enum AppError {
     #[error("Encountered an IO Error.")]
     IoError(#[from] std::io::Error),
-    #[error("Error while trying to deserialize value of type `{0}`. Reason: {1}")]
-    DeserializationError(String, String),
+    #[error("Error while trying to deserialize value. Constructor {0:#04x} was invalid.")]
+    DeserializationIllegalConstructorError(u8),
+    #[error("Iterator was empty or too short.")]
+    IteratorEmptyOrTooShortError,
 }

amqp-type/src/fixed_width/boolean.rs

@@ -41,14 +41,8 @@ impl Decode for bool {
         match (con, val) {
             (Some(c), Some(v)) if c == 0x56 && v == 0x00 => Ok(false),
             (Some(c), Some(v)) if c == 0x56 && v == 0x01 => Ok(true),
-            (Some(c), _) => Err(AppError::DeserializationError(
-                "bool".to_string(),
-                format!("bool cannot be constructed from value {:#04x}", c),
-            )),
-            (None, _) => Err(AppError::DeserializationError(
-                "bool".to_string(),
-                "Iterator was empty".to_string(),
-            )),
+            (Some(c), _) => Err(AppError::DeserializationIllegalConstructorError(c)),
+            (None, _) => Err(AppError::IteratorEmptyOrTooShortError),
         }
     }
 }
@@ -72,16 +66,10 @@ impl Decode for bool {
             return match val {
                 0x41 => Ok(true),
                 0x42 => Ok(false),
-                _ => Err(AppError::DeserializationError(
-                    "bool".to_string(),
-                    format!("bool cannot be constructed from value {:#04x}", val),
-                )),
+                _ => Err(AppError::DeserializationIllegalConstructorError(val)),
             };
         }
-        Err(AppError::DeserializationError(
-            "bool".to_string(),
-            "Iterator was empty".to_string(),
-        ))
+        Err(AppError::IteratorEmptyOrTooShortError)
     }
 }
 

amqp-type/src/fixed_width/ubyte.rs

@@ -1,7 +1,6 @@
 use crate::error::AppError;
-use crate::serde::encode::{Encode, Encoded};
 use crate::serde::decode::Decode;
-
+use crate::serde::encode::{Encode, Encoded};
 
 impl Encode for u8 {
     fn encode(&self) -> Encoded {
@@ -14,28 +13,27 @@ impl Decode for u8 {
         let mut iter = data.into_iter().peekable();
         match iter.peek() {
             Some(0x50) => true,
-            _ => false
+            _ => false,
         }
     }
 
     fn try_decode(mut iter: impl Iterator<Item = u8>) -> Result<Self, crate::error::AppError>
-        where
-            Self: Sized {
+    where
+        Self: Sized,
+    {
         let con = iter.next();
         let val = iter.next();
         match (con, val) {
             (Some(0x50), Some(x)) => Ok(x),
-            (Some(_), _) => Err(AppError::DeserializationError("ubyte (u8)".to_string(), "Wrong constructor".to_string())),
-            (_, _) => Err(AppError::DeserializationError("ubyte (u8)".to_string(), "Iterator was empty".to_string()))
+            (Some(c), _) => Err(AppError::DeserializationIllegalConstructorError(c)),
+            (_, _) => Err(AppError::IteratorEmptyOrTooShortError),
         }
     }
-    
 }
 
 #[cfg(test)]
 mod test {
 
-
     use super::*;
 
     #[test]
@@ -61,5 +59,4 @@ mod test {
         let val = vec![0x50, 0x10];
         assert_eq!(u8::try_decode(val.into_iter()).unwrap(), 16)
     }
-
 }

amqp-type/src/fixed_width/ushort.rs

@@ -1,7 +1,7 @@
-use crate::serde::encode::{Encode, Encoded};
+use crate::error::AppError;
 use crate::serde::decode::Decode;
-
-const BYTE_LEN: usize = 2;
+use crate::serde::encode::{Encode, Encoded};
+use crate::verify::verify_bytes_read_eq;
 
 impl Encode for u16 {
     fn encode(&self) -> Encoded {
@@ -13,24 +13,32 @@ impl Decode for u16 {
     fn can_decode(iter: impl Iterator<Item = u8>) -> bool {
         match iter.peekable().peek() {
             Some(0x60) => true,
-            _ => false
+            _ => false,
         }
     }
 
     fn try_decode(mut iter: impl Iterator<Item = u8>) -> Result<Self, crate::error::AppError>
-        where
-            Self: Sized {
-        let mut val_bytes = [0; BYTE_LEN];
-        let con = iter.next();
-        let mut index = 0;
-        for b in iter.take(BYTE_LEN) {
-            val_bytes[index] = b;
-            index += 1;
+    where
+        Self: Sized,
+    {
+        match iter.next() {
+            Some(0x60) => Ok(parse_u16(iter)?),
+            Some(c) => Err(AppError::DeserializationIllegalConstructorError(c)),
+            None => Err(AppError::IteratorEmptyOrTooShortError),
         }
-        Ok(u16::from_be_bytes(val_bytes))
     }
 }
 
+fn parse_u16(iter: impl Iterator<Item = u8>) -> Result<u16, AppError> {
+    let mut val_bytes = [0; 2];
+    let mut index = 0;
+    for b in iter.take(2) {
+        val_bytes[index] = b;
+        index += 1;
+    }
+    verify_bytes_read_eq(index, 2)?;
+    Ok(u16::from_be_bytes(val_bytes))
+}
 
 #[cfg(test)]
 mod test {
@@ -43,7 +51,6 @@ mod test {
         assert_eq!(val.encode().constructor(), 0x60);
     }
 
-    
     #[test]
     fn can_deocde_returns_true_if_constructor_is_valid() {
         let val = vec![0x60, 0x41];
@@ -61,4 +68,16 @@ mod test {
         let val = vec![0x60, 0x00, 0x10];
         assert_eq!(u16::try_decode(val.into_iter()).unwrap(), 16)
     }
+
+    #[test]
+    fn decode_returns_error_when_value_bytes_are_invalid() {
+        let val = vec![0x56, 0x44];
+        assert!(u16::try_decode(val.into_iter()).is_err());
+    }
+
+    #[test]
+    fn decode_returns_error_when_bytes_are_missing() {
+        let val = vec![0x60, 0x01];
+        assert!(u16::try_decode(val.into_iter()).is_err());
+    }
 }

amqp-type/src/lib.rs

@@ -5,3 +5,4 @@ mod error;
 mod fixed_width;
 mod serde;
 mod variable_width;
+mod verify;

amqp-type/src/serde/decode.rs

@@ -1,6 +1,5 @@
 use crate::error::AppError;
 
-
 #[derive(Hash, Eq, PartialEq)]
 pub struct Constructor(u8);
 

amqp-type/src/verify.rs

@@ -0,0 +1,11 @@
+use crate::error::AppError;
+
+
+
+pub fn verify_bytes_read_eq(actual: usize, expected: usize) -> Result<(), AppError> {
+    if actual == expected {
+        Ok(())
+    } else {
+        Err(AppError::IteratorEmptyOrTooShortError)
+    }
+}