Making Field be more generic.

src/field.rs

@@ -3,6 +3,203 @@ use chrono::prelude::*;
 use std::fmt;
 use uuid::Uuid;
 
+#[derive(Clone, Debug, PartialEq)]
+enum FieldType {
+    Action,
+    DateTime, 
+    Error,
+    StaticString,
+    Uuid,
+}
+
+#[derive(Clone)]
+struct Field2<T> {
+    data: T,
+    field_type: FieldType,
+}
+
+impl<T> Field2<T> {
+    fn data(&self) -> &T {
+        &self.data
+    }
+
+    fn get_type(&self) -> &FieldType {
+        &self.field_type
+    }
+}
+
+impl From<&str> for Field2<String> {
+    fn from(value: &str) -> Self {
+        Self {
+            data: value.to_string(),
+            field_type: FieldType::StaticString,
+        }
+    }
+}
+
+impl From<ActionType> for Field2<ActionType> {
+    fn from(value: ActionType) -> Self {
+        Self {
+            data: value,
+            field_type: FieldType::Action,
+        }
+    }
+}
+
+impl From<DateTime<Utc>> for Field2<DateTime<Utc>> {
+    fn from(value: DateTime<Utc>) -> Self {
+        Self {
+            data: value,
+            field_type: FieldType::DateTime,
+        }
+    }
+}
+
+impl From<ErrorType> for Field2<ErrorType> {
+    fn from(value: ErrorType) -> Self {
+        Self {
+            data: value,
+            field_type: FieldType::Error,
+        }
+    }
+}
+
+impl From<String> for Field2<String> {
+    fn from(value: String) -> Self {
+        Self {
+            data: value,
+            field_type: FieldType::StaticString,
+        }
+    }
+}
+
+impl From<Uuid> for Field2<Uuid>  {
+    fn from(value: Uuid) -> Self {
+        Self {
+            data: value,
+            field_type: FieldType::Uuid,
+        }
+    }
+}
+
+impl TryFrom<&str> for Field2<Uuid> {
+    type Error = String;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match Uuid::try_from(value) {
+            Ok(data) => Ok(Self {
+                data: data.clone(),
+                field_type: FieldType::Uuid,
+            }),
+            Err(err) => Err(err.to_string()),
+        }
+    }
+}
+
+impl TryFrom<String> for Field2<Uuid> {
+    type Error = String;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        match Uuid::try_from(value.as_str()) {
+            Ok(data) => Ok(Self {
+                data: data.clone(),
+                field_type: FieldType::Uuid,
+            }),
+            Err(err) => Err(err.to_string()),
+        }
+    }
+}
+
+#[cfg(test)]
+mod field2s {
+    use super::*;
+
+    #[test]
+    fn from_action_to_field() {
+        let actions = [ActionType::Add, ActionType::Update];
+        for expected in actions.into_iter() {
+            let field: Field2<ActionType> = expected.clone().into();
+            assert_eq!(field.get_type(), &FieldType::Action);
+            assert_eq!(field.data(), &expected);
+        }
+    }
+
+    #[test]
+    fn from_datetime_to_field() {
+        let expected = Utc::now();
+        let field: Field2<DateTime<Utc>> = expected.into();
+        assert_eq!(field.get_type(), &FieldType::DateTime);
+        assert_eq!(field.data(), &expected);
+    }
+
+    #[test]
+    fn from_error_to_field() {
+        let errors = [ErrorType::DocumentAlreadyExists, ErrorType::DocumentInvalidRequest];
+        for expected in errors.into_iter() {
+            let field: Field2<ErrorType> = expected.clone().into();
+            assert_eq!(field.get_type(), &FieldType::Error);
+            assert_eq!(field.data(), &expected);
+        }
+    }
+
+    #[test]
+    fn from_str_to_field() {
+        let expected = format!("string-{}", Uuid::new_v4());
+        let field: Field2<String> = expected.as_str().into();
+        assert_eq!(field.get_type(), &FieldType::StaticString);
+        assert_eq!(field.data(), &expected);
+    }
+
+    #[test]
+    fn from_string_to_field() {
+        let expected = format!("string-{}", Uuid::new_v4());
+        let field: Field2<String> = expected.clone().into();
+        assert_eq!(field.get_type(), &FieldType::StaticString);
+        assert_eq!(field.data(), &expected);
+    }
+
+    #[test]
+    fn from_uuid_to_field() {
+        let expected = Uuid::new_v4();
+        let field: Field2<Uuid> = expected.into();
+        assert_eq!(field.get_type(), &FieldType::Uuid);
+        assert_eq!(field.data(), &expected);
+    }
+
+    #[test]
+    fn from_uuid_str_to_field() {
+        let expected = Uuid::new_v4();
+        let field: Field2<Uuid> = expected.to_string().as_str().try_into().unwrap();
+        assert_eq!(field.get_type(), &FieldType::Uuid);
+        assert_eq!(field.data(), &expected);
+    }
+
+    #[test]
+    fn from_uuid_bad_str_fails() {
+        let expected = "Not a uuid";
+        let result: Result<Field2<Uuid>, String> = expected.try_into();
+        assert!(result.is_err(), "should have been an error");
+    }
+
+    #[test]
+    fn from_uuid_string_to_field() {
+        let expected = Uuid::new_v4();
+        let field: Field2<Uuid> = expected.to_string().try_into().unwrap();
+        assert_eq!(field.get_type(), &FieldType::Uuid);
+        assert_eq!(field.data(), &expected);
+    }
+
+    #[test]
+    fn from_uuid_bad_string_fails() {
+        let expected = "Not a uuid".to_string();
+        let result: Result<Field2<Uuid>, String> = expected.try_into();
+        assert!(result.is_err(), "should have been an error");
+    }
+}
+
+
+
+
 #[derive(Clone, Debug)]
 pub enum Field {
     Action(ActionType),

src/lib.rs

@@ -13,14 +13,14 @@ use queue::{Message, MsgType, Queue};
 use session::Session;
 use uuid::Uuid;
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum ActionType {
     Get,
     Add,
     Update,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum ErrorType {
     DocumentAlreadyExists,
     DocumentInvalidRequest,