refactor(tests): use public methods

Author: heitorlessa

aws_lambda_powertools/utilities/feature_flags/schema.py

@@ -116,30 +116,30 @@ def validate(self):
             raise ConfigurationError(f"Invalid condition, rule_name={self.rule_name}")
 
         for condition in self.conditions:
-            self._validate_condition(rule_name=self.rule_name, condition=condition)
+            self.validate_condition(rule_name=self.rule_name, condition=condition)
 
-    def _validate_condition(self, rule_name: str, condition: Dict[str, str]) -> None:
+    def validate_condition(self, rule_name: str, condition: Dict[str, str]) -> None:
         if not condition or not isinstance(condition, dict):
-            raise ConfigurationError(f"invalid condition type, not a dictionary, rule_name={rule_name}")
+            raise ConfigurationError(f"Invalid condition type, not a dictionary, rule_name={rule_name}")
 
-        self._validate_condition_action(condition=condition, rule_name=rule_name)
-        self._validate_condition_key(condition=condition, rule_name=rule_name)
-        self._validate_condition_value(condition=condition, rule_name=rule_name)
+        self.validate_condition_action(condition=condition, rule_name=rule_name)
+        self.validate_condition_key(condition=condition, rule_name=rule_name)
+        self.validate_condition_value(condition=condition, rule_name=rule_name)
 
     @staticmethod
-    def _validate_condition_action(condition: Dict[str, Any], rule_name: str):
+    def validate_condition_action(condition: Dict[str, Any], rule_name: str):
         action = condition.get(CONDITION_ACTION, "")
         if action not in RuleAction.__members__:
-            raise ConfigurationError(f"invalid action value, rule_name={rule_name}, action={action}")
+            raise ConfigurationError(f"Invalid action value, rule_name={rule_name}, action={action}")
 
     @staticmethod
-    def _validate_condition_key(condition: Dict[str, Any], rule_name: str):
+    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"Invalid key value, key has to be a non empty string, rule_name={rule_name}")
 
     @staticmethod
-    def _validate_condition_value(condition: Dict[str, Any], rule_name: str):
+    def validate_condition_value(condition: Dict[str, Any], rule_name: str):
         value = condition.get(CONDITION_VALUE, "")
         if not value:
             raise ConfigurationError(f"Missing condition value, rule_name={rule_name}")

tests/functional/feature_toggles/test_schema_validation.py

@@ -13,6 +13,7 @@
     RULE_DEFAULT_VALUE,
     RULE_NAME_KEY,
     RULES_KEY,
+    ConditionsValidator,
     RuleAction,
     RulesValidator,
     SchemaValidator,
@@ -269,49 +270,64 @@ def test_valid_condition_all_actions():
 
 def test_validate_condition_invalid_condition_type():
     # GIVEN an invalid condition type of empty dict
-    validator = SchemaValidator(EMPTY_SCHEMA)
-    condition = {}
-
-    # WHEN calling _validate_condition
-    with pytest.raises(ConfigurationError) as err:
-        validator._validate_condition("foo", condition)
+    rule_conditions = {"conditions": {}}
+    condition = rule_conditions[CONDITIONS_KEY]
+    rule_name = "dummy"
 
+    # WHEN calling validate_condition
     # THEN raise ConfigurationError
-    assert "invalid condition type" in str(err)
+    with pytest.raises(ConfigurationError, match="Invalid condition type"):
+        validator = ConditionsValidator(rule=rule_conditions, rule_name=rule_name)
+        validator.validate_condition(condition=condition, rule_name=rule_name)
 
 
 def test_validate_condition_invalid_condition_action():
     # GIVEN an invalid condition action of foo
-    validator = SchemaValidator(EMPTY_SCHEMA)
-    condition = {"action": "foo"}
-
-    # WHEN calling _validate_condition
-    with pytest.raises(ConfigurationError) as err:
-        validator._validate_condition("foo", condition)
+    rule_conditions = {
+        "conditions": [{"action": "INVALID", "key": "tenant_id", "value": "12345"}],
+    }
+    condition = rule_conditions[CONDITIONS_KEY][0]
+    rule_name = "dummy"
 
+    # WHEN calling validate_condition
     # THEN raise ConfigurationError
-    assert "invalid action value" in str(err)
+    with pytest.raises(ConfigurationError, match="Invalid action value"):
+        validator = ConditionsValidator(rule=rule_conditions, rule_name=rule_name)
+        validator.validate_condition_action(condition=condition, rule_name=rule_name)
 
 
 def test_validate_condition_invalid_condition_key():
     # GIVEN a configuration with a missing "key"
-    validator = SchemaValidator(EMPTY_SCHEMA)
-    condition = {"action": RuleAction.EQUALS.value}
+    rule_conditions = {
+        "conditions": [{"action": RuleAction.EQUALS.value, "value": "12345"}],
+    }
+    condition = rule_conditions[CONDITIONS_KEY][0]
+    rule_name = "dummy"
 
-    # WHEN calling _validate_condition
+    # WHEN calling validate_condition
     # THEN raise ConfigurationError
     with pytest.raises(ConfigurationError, match="Invalid key value"):
-        validator._validate_condition("foo", condition)
+        validator = ConditionsValidator(rule=rule_conditions, rule_name=rule_name)
+        validator.validate_condition_key(condition=condition, rule_name=rule_name)
 
 
 def test_validate_condition_missing_condition_value():
     # GIVEN a configuration with a missing condition value
-    validator = SchemaValidator(EMPTY_SCHEMA)
-    condition = {"action": RuleAction.EQUALS.value, "key": "Foo"}
+    rule_conditions = {
+        "conditions": [
+            {
+                "action": RuleAction.EQUALS.value,
+                "key": "tenant_id",
+            }
+        ],
+    }
+    condition = rule_conditions[CONDITIONS_KEY][0]
+    rule_name = "dummy"
 
-    # WHEN calling _validate_condition
+    # WHEN calling validate_condition
     with pytest.raises(ConfigurationError, match="Missing condition value"):
-        validator._validate_condition("foo", condition)
+        validator = ConditionsValidator(rule=rule_conditions, rule_name=rule_name)
+        validator.validate_condition_value(condition=condition, rule_name=rule_name)
 
 
 def test_validate_rule_invalid_rule_name():