Remove anyhow

Signed-off-by: Javier G. Sogo <[email protected]>

Author: jgsogo

src/errors.rs

@@ -54,7 +54,7 @@ pub enum Error {
 }
 
 #[derive(Debug, Error)]
-#[error("sdaf '{0}'")]
+#[error(transparent)]
 pub struct EntityEvaluationError(pub(crate) SegmentEvaluationError);
 
 impl From<SegmentEvaluationError> for Error {
@@ -110,51 +110,49 @@ impl<T> From<PoisonError<T>> for ConfigurationAccessError {
     }
 }
 
-#[derive(Debug, Error)]
-pub(crate) enum CheckOperatorErrorDetail {
-    #[error("Entity attribute is not a string.")]
-    StringExpected,
-
-    #[error("Entity attribute has unexpected type: Boolean.")]
-    BooleanExpected(#[from] std::str::ParseBoolError),
-
-    #[error("Entity attribute has unexpected type: Number.")]
-    NumberExpected(#[from] std::num::ParseFloatError),
-
-    #[error("Entity attribute is not a number.")]
-    EntityAttrNotANumber,
-
-    #[error("Operator not implemented.")]
-    OperatorNotImplemented,
-}
-
 #[derive(Debug, Error)]
 pub(crate) enum SegmentEvaluationError {
-    #[error("Operation")]
+    #[error(transparent)]
     SegmentEvaluationFailed(#[from] SegmentEvaluationErrorKind),
 
     #[error("Segment ID '{0}' not found")]
     SegmentIdNotFound(String),
 }
 #[derive(Debug, Error)]
-#[error("Operation")]
+#[error("Operation '{}' '{}' '{}' failed to evaluate: {}", segment_rule.attribute_name, segment_rule.operator,  value, source)]
 pub(crate) struct SegmentEvaluationErrorKind {
     pub(crate) segment: Segment,
     pub(crate) segment_rule: SegmentRule,
-    pub(crate) attr_value: AttrValue,
+    pub(crate) value: String,
     pub(crate) source: CheckOperatorErrorDetail,
 }
 
-impl From<(CheckOperatorErrorDetail, &Segment, &SegmentRule, &AttrValue)>
-    for SegmentEvaluationError
-{
-    fn from(value: (CheckOperatorErrorDetail, &Segment, &SegmentRule, &AttrValue)) -> Self {
-        let (source, segment, segment_rule, attr_value) = value;
+impl From<(CheckOperatorErrorDetail, &Segment, &SegmentRule, &String)> for SegmentEvaluationError {
+    fn from(value: (CheckOperatorErrorDetail, &Segment, &SegmentRule, &String)) -> Self {
+        let (source, segment, segment_rule, value) = value;
         Self::SegmentEvaluationFailed(SegmentEvaluationErrorKind {
             segment: segment.clone(),
             segment_rule: segment_rule.clone(),
-            attr_value: attr_value.clone(),
+            value: value.clone(),
             source,
         })
     }
 }
+
+#[derive(Debug, Error)]
+pub(crate) enum CheckOperatorErrorDetail {
+    #[error("Entity attribute is not a string.")]
+    StringExpected,
+
+    #[error("Entity attribute has unexpected type: Boolean.")]
+    BooleanExpected(#[from] std::str::ParseBoolError),
+
+    #[error("Entity attribute has unexpected type: Number.")]
+    NumberExpected(#[from] std::num::ParseFloatError),
+
+    #[error("Entity attribute is not a number.")]
+    EntityAttrNotANumber,
+
+    #[error("Operator not implemented.")]
+    OperatorNotImplemented,
+}

src/segment_evaluation.rs

@@ -96,12 +96,11 @@ fn belong_to_segment(
                     .values
                     .iter()
                     .find_map(|value| match check_operator(attr_value, operator, value) {
-                        Ok(true) => Some(Ok(())),
+                        Ok(true) => Some(Ok::<_, SegmentEvaluationError>(())),
                         Ok(false) => None,
-                        Err(e) => Some(Err(e)),
+                        Err(e) => Some(Err((e, segment, rule, value).into())),
                     })
-                    .transpose()
-                    .map_err(|e| (e, segment, rule, attr_value))?;
+                    .transpose()?;
                 // check if the candidate is good, or if the operator failed:
                 candidate.is_some()
             }
@@ -165,11 +164,11 @@ fn check_operator(
 #[cfg(test)]
 pub mod tests {
     use super::*;
+    use crate::errors::{EntityEvaluationError, Error, SegmentEvaluationErrorKind};
     use crate::{
         models::{ConfigValue, Segment, SegmentRule, Segments, TargetingRule},
         AttrValue,
     };
-    use crate::errors::Error;
     use rstest::*;
 
     #[fixture]
@@ -245,11 +244,20 @@ pub mod tests {
         //  Failed to evaluate entity: Failed to evaluate entity 'a2' against targeting rule '0'.
         //  Caused by: Segment 'non_existing_segment_id' not found.
         // We are checking here that the parts are present to allow debugging of config by the user:
-        let msg = rule.unwrap_err().to_string();
-        assert!(msg.contains("'a2'"));
-        assert!(msg.contains("'0'"));
-        assert!(msg.contains("'non_existing_segment_id'"));
-        assert!(msg.contains("not found"));
+        let e = rule.unwrap_err();
+        assert!(matches!(e, Error::EntityEvaluationError(_)));
+        let Error::EntityEvaluationError(EntityEvaluationError(
+            SegmentEvaluationError::SegmentIdNotFound(ref segment_id),
+        )) = e
+        else {
+            panic!("Error type mismatch!");
+        };
+        assert_eq!(segment_id, "non_existing_segment_id");
+        // let msg = rule.unwrap_err().to_string();
+        // assert!(msg.contains("'a2'"));
+        // assert!(msg.contains("'0'"));
+        // assert!(msg.contains("'non_existing_segment_id'"));
+        // assert!(msg.contains("not found"));
     }
 
     // SCENARIO - evaluating an operator fails. Meaning, [for example] user has added a numeric value(int/float) in appconfig segment attribute, but in their application they pass the attribute with a boolean value.
@@ -270,17 +278,15 @@ pub mod tests {
         // We are checking here that the parts are present to allow debugging of config by the user:
 
         let e = rule.unwrap_err();
-        assert!(matches!(
-            e,
-            Error::EntityEvaluationError(ref v)
-        ));
-
-        let msg = e.to_string();
-        assert_eq!(msg, "lol");
-        assert!(msg.contains("'a2'"));
-        assert!(msg.contains("'0'"));
-        assert!(msg.contains("'some_segment_id_1'"));
-        assert!(msg.contains("'name' 'is' 'heinz'"));
-        assert!(msg.contains("Entity attribute has unexpected type: Number"));
+        assert!(matches!(e, Error::EntityEvaluationError(_)));
+        let Error::EntityEvaluationError(EntityEvaluationError(
+            SegmentEvaluationError::SegmentEvaluationFailed(ref error),
+        )) = e
+        else {
+            panic!("Error type mismatch!");
+        };
+        assert_eq!(error.segment.name, "");
+        assert_eq!(error.segment_rule.attribute_name, "name");
+        assert_eq!(error.value, "heinz");
     }
 }