refactor: add SchemaValidationError

Author: heitorlessa

aws_lambda_powertools/utilities/feature_flags/exceptions.py

@@ -1,2 +1,6 @@
 class ConfigurationError(Exception):
-    """When a a configuration store raises an exception on config retrieval or parsing"""
+    """When a configuration store raises an exception on config retrieval or parsing"""
+
+
+class SchemaValidationError(Exception):
+    """When feature flag schema fails validation"""

aws_lambda_powertools/utilities/feature_flags/feature_flags.py

@@ -105,6 +105,8 @@ def get_configuration(self) -> Union[Dict[str, Dict], Dict]:
         ------
         ConfigurationError
             Any validation error
+        SchemaValidationError
+            When schema doesn't conform with feature flag schema
 
         Returns
         ------
@@ -170,6 +172,11 @@ def evaluate(self, *, name: str, context: Optional[Dict[str, Any]] = None, defau
         ------
         bool
             whether feature should be enabled or not
+
+        Raises
+        ------
+        SchemaValidationError
+            When schema doesn't conform with feature flag schema
         """
         if context is None:
             context = {}
@@ -214,6 +221,11 @@ def get_enabled_features(self, *, context: Optional[Dict[str, Any]] = None) -> L
             ```python
             ["premium_features", "my_feature_two", "always_true_feature"]
             ```
+
+        Raises
+        ------
+        SchemaValidationError
+            When schema doesn't conform with feature flag schema
         """
         if context is None:
             context = {}

aws_lambda_powertools/utilities/feature_flags/schema.py

@@ -3,7 +3,7 @@
 from typing import Any, Dict, List, Optional
 
 from .base import BaseValidator
-from .exceptions import ConfigurationError
+from .exceptions import SchemaValidationError
 
 logger = logging.getLogger(__name__)
 
@@ -26,6 +26,11 @@ class RuleAction(str, Enum):
 class SchemaValidator(BaseValidator):
     """Validates feature flag schema configuration
 
+    Raises
+    ------
+    SchemaValidationError
+        When schema doesn't conform with feature flag schema
+
     Schema
     ------
 
@@ -105,7 +110,7 @@ def __init__(self, schema: Dict[str, Any]):
     def validate(self) -> None:
         logger.debug("Validating schema")
         if not isinstance(self.schema, dict):
-            raise ConfigurationError(f"Features must be a dictionary, schema={str(self.schema)}")
+            raise SchemaValidationError(f"Features must be a dictionary, schema={str(self.schema)}")
 
         features = FeaturesValidator(schema=self.schema)
         features.validate()
@@ -127,11 +132,11 @@ def validate(self):
     @staticmethod
     def validate_feature(name, feature):
         if not feature or not isinstance(feature, dict):
-            raise ConfigurationError(f"Feature must be a non-empty dictionary, feature={name}")
+            raise SchemaValidationError(f"Feature must be a non-empty dictionary, feature={name}")
 
         default_value = feature.get(FEATURE_DEFAULT_VAL_KEY)
         if default_value is None or not isinstance(default_value, bool):
-            raise ConfigurationError(f"feature 'default' boolean key must be present, feature={name}")
+            raise SchemaValidationError(f"feature 'default' boolean key must be present, feature={name}")
 
 
 class RulesValidator(BaseValidator):
@@ -148,7 +153,7 @@ def validate(self):
             return
 
         if not isinstance(self.rules, dict):
-            raise ConfigurationError(f"Feature rules must be a dictionary, feature={self.feature_name}")
+            raise SchemaValidationError(f"Feature rules must be a dictionary, feature={self.feature_name}")
 
         for rule_name, rule in self.rules.items():
             logger.debug(f"Attempting to validate rule '{rule_name}'")
@@ -159,21 +164,21 @@ def validate(self):
     @staticmethod
     def validate_rule(rule, rule_name, feature_name):
         if not rule or not isinstance(rule, dict):
-            raise ConfigurationError(f"Feature rule must be a dictionary, feature={feature_name}")
+            raise SchemaValidationError(f"Feature rule must be a dictionary, feature={feature_name}")
 
         RulesValidator.validate_rule_name(rule_name=rule_name, feature_name=feature_name)
         RulesValidator.validate_rule_default_value(rule=rule, rule_name=rule_name)
 
     @staticmethod
     def validate_rule_name(rule_name: str, feature_name: str):
         if not rule_name or not isinstance(rule_name, str):
-            raise ConfigurationError(f"Rule name key must have a non-empty string, feature={feature_name}")
+            raise SchemaValidationError(f"Rule name key must have a non-empty string, feature={feature_name}")
 
     @staticmethod
     def validate_rule_default_value(rule: Dict, rule_name: str):
         rule_default_value = rule.get(RULE_MATCH_VALUE)
         if not isinstance(rule_default_value, bool):
-            raise ConfigurationError(f"'rule_default_value' key must have be bool, rule={rule_name}")
+            raise SchemaValidationError(f"'rule_default_value' key must have be bool, rule={rule_name}")
 
 
 class ConditionsValidator(BaseValidator):
@@ -183,15 +188,15 @@ def __init__(self, rule: Dict[str, Any], rule_name: str):
 
     def validate(self):
         if not self.conditions or not isinstance(self.conditions, list):
-            raise ConfigurationError(f"Invalid condition, rule={self.rule_name}")
+            raise SchemaValidationError(f"Invalid condition, rule={self.rule_name}")
 
         for condition in self.conditions:
             self.validate_condition(rule_name=self.rule_name, condition=condition)
 
     @staticmethod
     def validate_condition(rule_name: str, condition: Dict[str, str]) -> None:
         if not condition or not isinstance(condition, dict):
-            raise ConfigurationError(f"Feature rule condition must be a dictionary, rule={rule_name}")
+            raise SchemaValidationError(f"Feature rule condition must be a dictionary, rule={rule_name}")
 
         # Condition can contain PII data; do not log condition value
         logger.debug(f"Attempting to validate condition for '{rule_name}'")
@@ -204,18 +209,18 @@ def validate_condition_action(condition: Dict[str, Any], rule_name: str):
         action = condition.get(CONDITION_ACTION, "")
         if action not in RuleAction.__members__:
             allowed_values = [_action.value for _action in RuleAction]
-            raise ConfigurationError(
+            raise SchemaValidationError(
                 f"'action' value must be either {allowed_values}, rule_name={rule_name}, action={action}"
             )
 
     @staticmethod
     def validate_condition_key(condition: Dict[str, Any], rule_name: str):
         key = condition.get(CONDITION_KEY, "")
         if not key or not isinstance(key, str):
-            raise ConfigurationError(f"'key' value must be a non empty string, rule={rule_name}")
+            raise SchemaValidationError(f"'key' value must be a non empty string, rule={rule_name}")
 
     @staticmethod
     def validate_condition_value(condition: Dict[str, Any], rule_name: str):
         value = condition.get(CONDITION_VALUE, "")
         if not value:
-            raise ConfigurationError(f"'value' key must not be empty, rule={rule_name}")
+            raise SchemaValidationError(f"'value' key must not be empty, rule={rule_name}")

tests/functional/feature_toggles/test_feature_toggles.py

@@ -291,9 +291,8 @@ def test_toggles_no_match_rule_with_contains_action(mocker, config):
     mocked_app_config_schema = {
         "my_feature": {
             "default": expected_value,
-            "rules": [
-                {
-                    "rule_name": "tenant id is contained in [8, 2]",
+            "rules": {
+                "tenant id is contained in [8, 2]": {
                     "when_match": True,
                     "conditions": [
                         {
@@ -302,8 +301,8 @@ def test_toggles_no_match_rule_with_contains_action(mocker, config):
                             "value": ["8", "2"],
                         }
                     ],
-                },
-            ],
+                }
+            },
         }
     }
     feature_flags = init_feature_flags(mocker, mocked_app_config_schema, config)

tests/functional/feature_toggles/test_schema_validation.py

@@ -2,7 +2,7 @@
 
 import pytest  # noqa: F401
 
-from aws_lambda_powertools.utilities.feature_flags.exceptions import ConfigurationError
+from aws_lambda_powertools.utilities.feature_flags.exceptions import SchemaValidationError
 from aws_lambda_powertools.utilities.feature_flags.schema import (
     CONDITION_ACTION,
     CONDITION_KEY,
@@ -24,7 +24,7 @@
 
 def test_invalid_features_dict():
     validator = SchemaValidator(schema=[])
-    with pytest.raises(ConfigurationError):
+    with pytest.raises(SchemaValidationError):
         validator.validate()
 
 
@@ -45,7 +45,7 @@ def test_empty_features_not_fail():
 )
 def test_invalid_feature(schema):
     validator = SchemaValidator(schema)
-    with pytest.raises(ConfigurationError):
+    with pytest.raises(SchemaValidationError):
         validator.validate()
 
 
@@ -73,7 +73,7 @@ def test_invalid_rule():
         }
     }
     validator = SchemaValidator(schema)
-    with pytest.raises(ConfigurationError):
+    with pytest.raises(SchemaValidationError):
         validator.validate()
 
     # rules RULE_MATCH_VALUE is not bool
@@ -88,7 +88,7 @@ def test_invalid_rule():
         }
     }
     validator = SchemaValidator(schema)
-    with pytest.raises(ConfigurationError):
+    with pytest.raises(SchemaValidationError):
         validator.validate()
 
     # missing conditions list
@@ -103,7 +103,7 @@ def test_invalid_rule():
         }
     }
     validator = SchemaValidator(schema)
-    with pytest.raises(ConfigurationError):
+    with pytest.raises(SchemaValidationError):
         validator.validate()
 
     # condition list is empty
@@ -116,7 +116,7 @@ def test_invalid_rule():
         }
     }
     validator = SchemaValidator(schema)
-    with pytest.raises(ConfigurationError):
+    with pytest.raises(SchemaValidationError):
         validator.validate()
 
     # condition is invalid type, not list
@@ -129,7 +129,7 @@ def test_invalid_rule():
         }
     }
     validator = SchemaValidator(schema)
-    with pytest.raises(ConfigurationError):
+    with pytest.raises(SchemaValidationError):
         validator.validate()
 
 
@@ -147,7 +147,7 @@ def test_invalid_condition():
         }
     }
     validator = SchemaValidator(schema)
-    with pytest.raises(ConfigurationError):
+    with pytest.raises(SchemaValidationError):
         validator.validate()
 
     # missing condition key and value
@@ -163,7 +163,7 @@ def test_invalid_condition():
         }
     }
     validator = SchemaValidator(schema)
-    with pytest.raises(ConfigurationError):
+    with pytest.raises(SchemaValidationError):
         validator.validate()
 
     # invalid condition key type, not string
@@ -183,7 +183,7 @@ def test_invalid_condition():
         }
     }
     validator = SchemaValidator(schema)
-    with pytest.raises(ConfigurationError):
+    with pytest.raises(SchemaValidationError):
         validator.validate()
 
 
@@ -229,8 +229,8 @@ def test_validate_condition_invalid_condition_type():
     condition = {}
 
     # WHEN calling validate_condition
-    # THEN raise ConfigurationError
-    with pytest.raises(ConfigurationError, match="Feature rule condition must be a dictionary"):
+    # THEN raise SchemaValidationError
+    with pytest.raises(SchemaValidationError, match="Feature rule condition must be a dictionary"):
         ConditionsValidator.validate_condition(condition=condition, rule_name="dummy")
 
 
@@ -239,8 +239,8 @@ def test_validate_condition_invalid_condition_action():
     condition = {"action": "INVALID", "key": "tenant_id", "value": "12345"}
 
     # WHEN calling validate_condition
-    # THEN raise ConfigurationError
-    with pytest.raises(ConfigurationError, match="'action' value must be either"):
+    # THEN raise SchemaValidationError
+    with pytest.raises(SchemaValidationError, match="'action' value must be either"):
         ConditionsValidator.validate_condition_action(condition=condition, rule_name="dummy")
 
 
@@ -249,8 +249,8 @@ def test_validate_condition_invalid_condition_key():
     condition = {"action": RuleAction.EQUALS.value, "value": "12345"}
 
     # WHEN calling validate_condition
-    # THEN raise ConfigurationError
-    with pytest.raises(ConfigurationError, match="'key' value must be a non empty string"):
+    # THEN raise SchemaValidationError
+    with pytest.raises(SchemaValidationError, match="'key' value must be a non empty string"):
         ConditionsValidator.validate_condition_key(condition=condition, rule_name="dummy")
 
 
@@ -262,21 +262,21 @@ def test_validate_condition_missing_condition_value():
     }
 
     # WHEN calling validate_condition
-    with pytest.raises(ConfigurationError, match="'value' key must not be empty"):
+    with pytest.raises(SchemaValidationError, match="'value' key must not be empty"):
         ConditionsValidator.validate_condition_value(condition=condition, rule_name="dummy")
 
 
 def test_validate_rule_invalid_rule_type():
     # GIVEN an invalid rule type of empty list
     # WHEN calling validate_rule
-    # THEN raise ConfigurationError
-    with pytest.raises(ConfigurationError, match="Feature rule must be a dictionary"):
+    # THEN raise SchemaValidationError
+    with pytest.raises(SchemaValidationError, match="Feature rule must be a dictionary"):
         RulesValidator.validate_rule(rule=[], rule_name="dummy", feature_name="dummy")
 
 
 def test_validate_rule_invalid_rule_name():
     # GIVEN a rule name is empty
     # WHEN calling validate_rule_name
-    # THEN raise ConfigurationError
-    with pytest.raises(ConfigurationError, match="Rule name key must have a non-empty string"):
+    # THEN raise SchemaValidationError
+    with pytest.raises(SchemaValidationError, match="Rule name key must have a non-empty string"):
         RulesValidator.validate_rule_name(rule_name="", feature_name="dummy")