Merge pull request #171 from rruckley/UnitTests

Unit tests - 3rd installment

src/tmf700/shipment_specification.rs

@@ -107,6 +107,7 @@ pub struct CharacteristicSpecification {
 
 /// Shipping Order Characteristic Speficiation
 #[derive(Clone,Default,Debug,HasValidity,Deserialize,Serialize)]
+#[serde(rename_all = "camelCase")]
 pub struct CharacteristicSpecificationRelationship {
     characteristic_specification_id : String,
     name : String,
@@ -119,6 +120,7 @@ pub struct CharacteristicSpecificationRelationship {
 
 /// Shipping Characteristic Value Specification
 #[derive(Clone,Default,Debug,HasValidity,Deserialize,Serialize)]
+#[serde(rename_all = "camelCase")]
 pub struct CharacteristicValueSpecification {
     is_default: bool,
     range_interval: String,
@@ -135,7 +137,7 @@ pub struct CharacteristicValueSpecification {
 mod test {
     use crate::{HasId, HasName};
 
-    use super::{CharacteristicSpecification, ShipmentSpecificationRefOrValue, ShipmentSpecificationRelationship};
+    use super::*;
 
 
     const SHIPSPEC_JSON : &str = "{
@@ -161,6 +163,25 @@ mod test {
         \"regex\" : \"Regex\",
         \"valueType\" :\"String\"
     }";
+
+    const CHARSPECREL_JSON : &str = "{
+        \"characteristicSpecificationId\" : \"CS123\",
+        \"name\" : \"CharacteristicSpecificationName\",
+        \"parentSpecificationHref\" : \"http://example.com/tmf700/specification/CS456\",
+        \"parentSpecificationId\" : \"CS456\",
+        \"relationshipType\" : \"RelationshipType\"
+    }";
+
+    const CHARVALSPEC_JSON : &str = "{
+        \"isDefault\" : false,
+        \"rangeInterval\" : \"1\",
+        \"regex\" : \"Regex\",
+        \"unitOfMeasure\" : \"Units\",
+        \"value\" : \"2\",
+        \"valueFrom\" : 3,
+        \"valueTo\" : 4,
+        \"valueType\" : \"ValueType\"
+    }";
    #[test]
    fn test_shipspec_deserialize() {
         let shipspec : ShipmentSpecificationRefOrValue = serde_json::from_str(SHIPSPEC_JSON).unwrap();
@@ -186,12 +207,38 @@ mod test {
     #[test]
     fn test_charspec_deserialize() {
         let charspec : CharacteristicSpecification = serde_json::from_str(CHARSPEC_JSON).unwrap();
+
+        assert_eq!(charspec.configurable,true);
+        assert_eq!(charspec.description.as_str(),"Description");
+        assert_eq!(charspec.extensible,false);
+        assert_eq!(charspec.is_unique,false);
+        assert_eq!(charspec.min_cardinality,1);
+        assert_eq!(charspec.max_cardinality,2);
+        assert_eq!(charspec.name.is_some(),true);
     }
 
-   #[test]
-   fn test_charspecrel_deserialize() {}
+    #[test]
+    fn test_charspecrel_deserialize() {
+        let charspecrel : CharacteristicSpecificationRelationship = serde_json::from_str(CHARSPECREL_JSON).unwrap();
 
-   #[test]
-   fn test_charvalspec_deserialize() {}
+        assert_eq!(charspecrel.characteristic_specification_id.as_str(),"CS123");
+        assert_eq!(charspecrel.name.as_str(),"CharacteristicSpecificationName");
+        assert_eq!(charspecrel.parent_specification_id.as_str(),"CS456");
+        assert_eq!(charspecrel.relationship_type.as_str(),"RelationshipType");
+    }
+
+    #[test]
+    fn test_charvalspec_deserialize() {
+        let charvalspec : CharacteristicValueSpecification = serde_json::from_str(CHARVALSPEC_JSON).unwrap();
+
+        assert_eq!(charvalspec.is_default,false);
+        assert_eq!(charvalspec.range_interval.as_str(),"1");
+        assert_eq!(charvalspec.regex.as_str(),"Regex");
+        assert_eq!(charvalspec.unit_of_measure.as_str(),"Units");
+        assert_eq!(charvalspec.value.as_str(),"2");
+        assert_eq!(charvalspec.value_from,3);
+        assert_eq!(charvalspec.value_to,4);
+        assert_eq!(charvalspec.value_type.as_str(),"ValueType");
+    }
 
 }

src/tmf700/shipping_order_item.rs

@@ -11,7 +11,7 @@ const CLASS_PATH : &str = "shippingOrderItem";
 const NEW_STATUS : &str = "New";
 
 /// Shipping Item Action Type
-#[derive(Clone,Default,Debug,Deserialize,Serialize)]
+#[derive(Clone,Default,Debug,Deserialize,PartialEq, Serialize)]
 pub enum ShippingOrderItemActionType {
     /// Add new item
     #[default]
@@ -66,12 +66,47 @@ impl ShippingOrderItem {
 
 #[cfg(test)]
 mod test {
-    use super::{ShippingOrderItem, NEW_STATUS};
+
+    use crate::tmf700::shipping_instruction::ShippingInstruction;
+
+    use super::{ShippingOrderItem, ShippingOrderItemActionType , NEW_STATUS};
+
+    const ITEMACTION_JSON : &str = "\"Add\"";
+    const ORDERITEM_JSON : &str = "{
+        \"action\" : \"Add\",
+        \"quantity\" : \"1\",
+        \"status\" : \"Status\"
+    }";
 
     #[test]
     fn shipping_item_new() {
         let item = ShippingOrderItem::new();
 
         assert_eq!(item.status, NEW_STATUS.to_string());
     }
+
+    #[test]
+    fn test_itemaction_deserialize() {
+        let itemaction : ShippingOrderItemActionType  = serde_json::from_str(ITEMACTION_JSON).unwrap();
+
+        assert_eq!(itemaction,ShippingOrderItemActionType::Add);
+    }
+
+    #[test]
+    fn test_orderitem_deserialize() {
+        let orderitem : ShippingOrderItem = serde_json::from_str(ORDERITEM_JSON).unwrap();
+
+        assert_eq!(orderitem.action,ShippingOrderItemActionType::Add);
+        assert_eq!(orderitem.quantity.as_str(),"1");
+        assert_eq!(orderitem.status.as_str(),"Status");
+    }
+
+    #[test]
+    fn test_orderitem_instruction() {
+        let orderitem = ShippingOrderItem::new()
+            .instruction(ShippingInstruction::new("SomeInstruction"));
+
+        assert_eq!(orderitem.shipping_instruction.is_some(),true);
+        assert_eq!(orderitem.shipping_instruction.unwrap().label_message.is_some(),true);
+    }
 }

src/tmf724/incident.rs

@@ -10,7 +10,6 @@ const CLASS_PATH : &str = "incident";
 
 /// Incident Priority
 #[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
-#[serde(rename_all = "camelCase")]
 pub enum PriorityType {
     /// Critical
     Critical,
@@ -25,7 +24,6 @@ pub enum PriorityType {
 
 /// Incident Urgency 
 #[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
-#[serde(rename_all = "camelCase")]
 pub enum UrgencyType {
     /// Critical
     Critical,
@@ -40,7 +38,6 @@ pub enum UrgencyType {
 
 /// Incident Acknowledge State
 #[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
-#[serde(rename_all = "camelCase")]
 pub enum IncidentAckStateType {
     /// Acknowledged
     Acknowledged,
@@ -51,7 +48,6 @@ pub enum IncidentAckStateType {
 
 /// Incident Status
 #[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
-#[serde(rename_all = "camelCase")]
 pub enum IncidentStateType {
     /// Raised
     #[default]
@@ -64,7 +60,6 @@ pub enum IncidentStateType {
 
 /// Incident Impact
 #[derive(Clone, Debug, Default, Deserialize,PartialEq, Serialize)]
-#[serde(rename_all = "camelCase")]
 pub enum ImpactType {
     /// Extensive (Highest)
     Extensive,
@@ -216,6 +211,20 @@ impl Incident {
 mod test {
     use super::*;
 
+    const PRIORITY_JSON : &str = "\"Medium\"";
+    const URGENCY_JSON : &str = "\"Medium\"";
+    const ACKSTATE_JSON : &str = "\"Unacknowledged\"";
+    const STATE_JSON : &str = "\"Raised\"";
+    const IMPACT_JSON : &str = "\"Moderate\"";
+
+    const CHAR_JSON : &str = "{
+        \"id\" : \"CHAR123\",
+        \"name\" :\"CharacteristicName\",
+        \"value\" : \"Value\",
+        \"valueType\" : \"ValueType\"
+    }";
+
+
     #[test]
     fn test_incident_new_name() {
         let incident = Incident::new("AnIncident");
@@ -257,4 +266,48 @@ mod test {
 
         assert_eq!(incident.ack_state, Some(IncidentAckStateType::Unacknowledged));
     }
+    #[test]
+    fn test_priority_deserialize() {
+        let priority : PriorityType = serde_json::from_str(PRIORITY_JSON).unwrap();
+
+        assert_eq!(priority,PriorityType::Medium);
+    }
+
+    #[test]
+    fn test_urgency_deseralize() {
+        let urgency : UrgencyType = serde_json::from_str(URGENCY_JSON).unwrap();
+
+        assert_eq!(urgency,UrgencyType::Medium);
+    }
+
+    #[test]
+    fn test_ackstate_deserialize() {
+        let ackstate : IncidentAckStateType = serde_json::from_str(ACKSTATE_JSON).unwrap();
+
+        assert_eq!(ackstate,IncidentAckStateType::Unacknowledged);
+    }
+
+    #[test]
+    fn test_state_deseralize() {
+        let state : IncidentStateType = serde_json::from_str(STATE_JSON).unwrap();
+
+        assert_eq!(state,IncidentStateType::Raised);
+    }
+
+    #[test]
+    fn test_impact_deseralize() {
+        let impact : ImpactType = serde_json::from_str(IMPACT_JSON).unwrap();
+
+        assert_eq!(impact, ImpactType::Moderate);
+    }
+
+    #[test]
+    fn test_char_deserialize() {
+        let characteristic : Characteristic = serde_json::from_str(CHAR_JSON).unwrap();
+
+        assert_eq!(characteristic.id.as_str(),"CHAR123");
+        assert_eq!(characteristic.name.as_str(),"CharacteristicName");
+        assert_eq!(characteristic.value.as_str(),"Value");
+        assert_eq!(characteristic.value_type.as_str(), "ValueType");
+    }
 }