feat: added tests

crates/superposition_types/src/lib.rs

@@ -175,3 +175,216 @@ impl TryFrom<Map<String, Value>> for Overrides {
         Overrides::new(s, ValidationType::DEFAULT).map_err(|err| err.message())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn ok_test_deserialize_condition() -> superposition::Result<()> {
+        let db_request_condition_map: Map<String, Value> = Map::from_iter(vec![(
+            "and".to_string(),
+            json!([
+                {
+                "==": [
+                    {
+                        "var": "clientId"
+                    },
+                    "meesho"
+                ]
+                }
+            ]),
+        )]);
+
+        let default_request_condition_map: Map<String, Value> = Map::from_iter(vec![(
+            "and".to_string(),
+            json!([
+                {
+                "==": [
+                    {
+                        "var": "os"
+                    },
+                    "ios"
+                ]
+                }
+            ]),
+        )]);
+
+        let exp_request_condition_map: Map<String, Value> = Map::from_iter(vec![(
+            "and".to_string(),
+            json!([
+                {
+                "==": [
+                    {
+                        "var": "clientId"
+                    },
+                    "meesho"
+                ]
+                }
+            ]),
+        )]);
+
+        let db_condition = serde_json::from_str::<Condition>(
+            &json!(db_request_condition_map).to_string(),
+        )
+        .unwrap();
+        let db_expected_condition =
+            Condition::new(db_request_condition_map, ValidationType::DB)?;
+        assert_eq!(db_condition, db_expected_condition);
+
+        let default_condition = serde_json::from_str::<Condition>(
+            &json!(default_request_condition_map).to_string(),
+        )
+        .unwrap();
+        let default_expected_condition =
+            Condition::new(default_request_condition_map, ValidationType::DEFAULT)?;
+        assert_eq!(default_condition, default_expected_condition);
+
+        let exp_condition = serde_json::from_str::<Condition>(
+            &json!(exp_request_condition_map).to_string(),
+        )
+        .unwrap();
+        let exp_expected_condition =
+            Condition::new(exp_request_condition_map, ValidationType::EXPERIMENTAL)?;
+        assert_eq!(exp_condition, exp_expected_condition);
+
+        let empty_exp_condition =
+            serde_json::from_str::<Condition>(&json!({}).to_string()).unwrap();
+        let empty_exp_expected_condition =
+            Condition::new(Map::new(), ValidationType::EXPERIMENTAL)?;
+        assert_eq!(empty_exp_condition, empty_exp_expected_condition);
+
+        Ok(())
+    }
+
+    #[test]
+    fn fail_test_deserialize_condition() -> superposition::Result<()> {
+        let request_condition_map: Map<String, Value> = Map::from_iter(vec![(
+            "and".to_string(),
+            json!([
+                {
+                "..": [
+                    {
+                        "var": "clientId"
+                    },
+                    "meesho"
+                ]
+                }
+            ]),
+        )]);
+
+        let exp_condition_map: Map<String, Value> = Map::from_iter(vec![(
+            "and".to_string(),
+            json!([
+                {
+                "in": [
+                    "variant-id",
+                    {
+                        "var": "variantIds"
+                    }
+                ]
+                }
+            ]),
+        )]);
+
+        let db_condition =
+            serde_json::from_str::<Condition>(&json!(request_condition_map).to_string())
+                .unwrap();
+        let db_expected_condition =
+            Condition::new(request_condition_map.clone(), ValidationType::DB)?;
+        assert_eq!(db_condition, db_expected_condition);
+
+        let exp_condition = serde_json::from_str::<Condition>(
+            &json!(request_condition_map.clone()).to_string(),
+        )
+        .map_err(|_| "failed parsing".to_string());
+        assert_eq!(
+            json!(exp_condition).to_string().contains("failed parsing"),
+            true
+        );
+
+        let exp_condition = serde_json::from_str::<Condition>(
+            &json!(exp_condition_map.clone()).to_string(),
+        )
+        .map_err(|err| err.to_string());
+        assert_eq!(
+            json!(exp_condition)
+                .to_string()
+                .contains("experiment's context should not contain variantIds dimension"),
+            true
+        );
+
+        let default_condition = serde_json::from_str::<Condition>(
+            &json!(request_condition_map.clone()).to_string(),
+        )
+        .map_err(|_| "failed parsing".to_string());
+        assert_eq!(
+            json!(default_condition)
+                .to_string()
+                .contains("failed parsing"),
+            true
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_deserialize_override() -> superposition::Result<()> {
+        let override_map = Map::from_iter(vec![
+            ("key1".to_string(), json!("val1")),
+            ("key2".to_string(), json!(5)),
+        ]);
+
+        let empty_override_map = Map::new();
+
+        let db_overrides =
+            serde_json::from_str::<Overrides>(&json!(override_map).to_string()).unwrap();
+        let db_expected_overrides =
+            Overrides::new(override_map.clone(), ValidationType::DB)?;
+        assert_eq!(db_overrides, db_expected_overrides);
+
+        let exp_overrides =
+            serde_json::from_str::<Overrides>(&json!(override_map).to_string()).unwrap();
+        let exp_expected_overrides =
+            Overrides::new(override_map.clone(), ValidationType::EXPERIMENTAL)?;
+        assert_eq!(exp_overrides, exp_expected_overrides);
+
+        let default_overrides =
+            serde_json::from_str::<Overrides>(&json!(override_map).to_string()).unwrap();
+        let default_expected_overrides =
+            Overrides::new(override_map.clone(), ValidationType::DEFAULT)?;
+        assert_eq!(default_overrides, default_expected_overrides);
+
+        let empty_db_overrides =
+            serde_json::from_str::<Overrides>(&json!(empty_override_map).to_string())
+                .unwrap();
+        let empty_db_expected_overrides =
+            Overrides::new(empty_override_map.clone(), ValidationType::DB)?;
+        assert_eq!(empty_db_overrides, empty_db_expected_overrides);
+
+        let empty_exp_condition = serde_json::from_str::<Overrides>(
+            &json!(empty_override_map.clone()).to_string(),
+        )
+        .map_err(|_| "failed parsing".to_string());
+        assert_eq!(
+            json!(empty_exp_condition)
+                .to_string()
+                .contains("failed parsing"),
+            true
+        );
+
+        let empty_default_condition = serde_json::from_str::<Overrides>(
+            &json!(empty_override_map.clone()).to_string(),
+        )
+        .map_err(|_| "failed parsing".to_string());
+        assert_eq!(
+            json!(empty_default_condition)
+                .to_string()
+                .contains("failed parsing"),
+            true
+        );
+
+        Ok(())
+    }
+}