Merge pull request #36 from gyft/docs/dynamic-feature-toggles-patch

heitorlessa · web-flow · commit 6ed29ea301c6 · 2021-08-03T05:36:29.000+02:00
diff --git a/aws_lambda_powertools/utilities/feature_flags/feature_flags.py b/aws_lambda_powertools/utilities/feature_flags/feature_flags.py
@@ -57,7 +57,7 @@ def _is_rule_matched(self, feature_name: str, rule: Dict[str, Any], context: Dic
                 return False
             # if we got here, all conditions match
             logger.debug(
-                f"rule matched, rule_name={rule_name}, rule_default_value={rule_default_value}, " f"name={feature_name}"
+                f"rule matched, rule_name={rule_name}, rule_default_value={rule_default_value}, name={feature_name}"
             )
             return True
         return False
@@ -160,7 +160,7 @@ def evaluate(self, *, name: str, context: Optional[Dict[str, Any]] = None, defau
         feature = features.get(name)
         if feature is None:
             logger.debug(
-                f"feature does not appear in configuration, using provided default, " f"name={name}, default={default}"
+                f"feature does not appear in configuration, using provided default, name={name}, default={default}"
             )
             return default
 
diff --git a/aws_lambda_powertools/utilities/feature_flags/schema.py b/aws_lambda_powertools/utilities/feature_flags/schema.py
@@ -38,12 +38,9 @@ def validate(self) -> None:
 
 
 class FeaturesValidator(BaseValidator):
-    def __init__(self, schema):
+    def __init__(self, schema: Dict):
         self.schema = schema
-        self.features: Optional[Dict[str, Dict]] = None
-
-        if isinstance(self.schema, dict):
-            self.features = self.schema.get(FEATURES_KEY)
+        self.features: Optional[Dict[str, Dict]] = self.schema.get(FEATURES_KEY)
 
     def validate(self):
         if not isinstance(self.features, dict):
@@ -71,13 +68,13 @@ def __init__(self, feature: Dict[str, Any], feature_name: str):
         self.rules: Optional[List[Dict]] = self.feature.get(RULES_KEY)
 
     def validate(self):
-        if not isinstance(self.rules, list):
-            raise ConfigurationError(f"Feature rules is not a list, feature_name={self.feature_name}")
-
         if not self.rules:
             logger.debug("Rules are empty, ignoring validation")
             return
 
+        if not isinstance(self.rules, list):
+            raise ConfigurationError(f"Feature rules is not a list, feature_name={self.feature_name}")
+
         for rule in self.rules:
             self.validate_rule(rule, self.feature)
             conditions = ConditionsValidator(rule=rule, rule_name=rule.get(RULE_NAME_KEY))
diff --git a/tests/functional/feature_toggles/test_feature_toggles.py b/tests/functional/feature_toggles/test_feature_toggles.py
@@ -279,7 +279,7 @@ def test_toggles_match_rule_with_contains_action(mocker, config):
                 "feature_default_value": False,
                 "rules": [
                     {
-                        "rule_name": "tenant id is contained in [6,2] ",
+                        "rule_name": "tenant id is contained in [6, 2]",
                         "value_when_applies": expected_value,
                         "conditions": [
                             {
@@ -306,7 +306,7 @@ def test_toggles_no_match_rule_with_contains_action(mocker, config):
                 "feature_default_value": expected_value,
                 "rules": [
                     {
-                        "rule_name": "tenant id is contained in [6,2] ",
+                        "rule_name": "tenant id is contained in [8, 2]",
                         "value_when_applies": True,
                         "conditions": [
                             {
@@ -333,7 +333,7 @@ def test_multiple_features_enabled(mocker, config):
                 "feature_default_value": False,
                 "rules": [
                     {
-                        "rule_name": "tenant id is contained in [6,2] ",
+                        "rule_name": "tenant id is contained in [6, 2]",
                         "value_when_applies": True,
                         "conditions": [
                             {
@@ -366,7 +366,7 @@ def test_multiple_features_only_some_enabled(mocker, config):
                 "feature_default_value": False,
                 "rules": [
                     {
-                        "rule_name": "tenant id is contained in [6,2] ",
+                        "rule_name": "tenant id is contained in [6, 2]",
                         "value_when_applies": True,
                         "conditions": [
                             {
diff --git a/tests/functional/feature_toggles/test_schema_validation.py b/tests/functional/feature_toggles/test_schema_validation.py
@@ -33,11 +33,13 @@ def test_invalid_features_dict():
 
     schema = []
     # invalid type
+    validator = SchemaValidator(schema)
     with pytest.raises(ConfigurationError):
         validator.validate()
 
     # invalid features key
     schema = {FEATURES_KEY: []}
+    validator = SchemaValidator(schema)
     with pytest.raises(ConfigurationError):
         validator.validate()
 
@@ -57,33 +59,38 @@ def test_invalid_feature_dict():
 
     # empty feature dict
     schema = {FEATURES_KEY: {"my_feature": {}}}
+    validator = SchemaValidator(schema)
     with pytest.raises(ConfigurationError):
         validator.validate()
 
     # invalid FEATURE_DEFAULT_VAL_KEY type, not boolean
     schema = {FEATURES_KEY: {"my_feature": {FEATURE_DEFAULT_VAL_KEY: "False"}}}
+    validator = SchemaValidator(schema)
     with pytest.raises(ConfigurationError):
         validator.validate()
 
     # invalid FEATURE_DEFAULT_VAL_KEY type, not boolean #2
     schema = {FEATURES_KEY: {"my_feature": {FEATURE_DEFAULT_VAL_KEY: 5}}}
+    validator = SchemaValidator(schema)
     with pytest.raises(ConfigurationError):
         validator.validate()
 
     # invalid rules type, not list
     schema = {FEATURES_KEY: {"my_feature": {FEATURE_DEFAULT_VAL_KEY: False, RULES_KEY: "4"}}}
+    validator = SchemaValidator(schema)
     with pytest.raises(ConfigurationError):
         validator.validate()
 
 
 def test_valid_feature_dict():
-    # no rules list at all
-    schema = {FEATURES_KEY: {"my_feature": {FEATURE_DEFAULT_VAL_KEY: False}}}
+    # empty rules list
+    schema = {FEATURES_KEY: {"my_feature": {FEATURE_DEFAULT_VAL_KEY: False, RULES_KEY: []}}}
     validator = SchemaValidator(schema)
     validator.validate()
 
-    # empty rules list
-    schema = {FEATURES_KEY: {"my_feature": {FEATURE_DEFAULT_VAL_KEY: False, RULES_KEY: []}}}
+    # no rules list at all
+    schema = {FEATURES_KEY: {"my_feature": {FEATURE_DEFAULT_VAL_KEY: False}}}
+    validator = SchemaValidator(schema)
     validator.validate()
 
 
@@ -118,6 +125,7 @@ def test_invalid_rule():
             }
         }
     }
+    validator = SchemaValidator(schema)
     with pytest.raises(ConfigurationError):
         validator.validate()
 
@@ -135,6 +143,7 @@ def test_invalid_rule():
             }
         }
     }
+    validator = SchemaValidator(schema)
     with pytest.raises(ConfigurationError):
         validator.validate()
 
@@ -149,6 +158,7 @@ def test_invalid_rule():
             }
         }
     }
+    validator = SchemaValidator(schema)
     with pytest.raises(ConfigurationError):
         validator.validate()
 
@@ -163,6 +173,7 @@ def test_invalid_rule():
             }
         }
     }
+    validator = SchemaValidator(schema)
     with pytest.raises(ConfigurationError):
         validator.validate()
 
@@ -202,6 +213,7 @@ def test_invalid_condition():
             }
         }
     }
+    validator = SchemaValidator(schema)
     with pytest.raises(ConfigurationError):
         validator.validate()
 
@@ -224,6 +236,7 @@ def test_invalid_condition():
             }
         }
     }
+    validator = SchemaValidator(schema)
     with pytest.raises(ConfigurationError):
         validator.validate()
 

Original file line number	Diff line number	Diff line change
`@@ -279,7 +279,7 @@ def test_toggles_match_rule_with_contains_action(mocker, config):`
`279`	`279`	`"feature_default_value": False,`
`280`	`280`	`"rules": [`
`281`	`281`	`{`
`282`		`- "rule_name": "tenant id is contained in [6,2] ",`
	`282`	`+ "rule_name": "tenant id is contained in [6, 2]",`
`283`	`283`	`"value_when_applies": expected_value,`
`284`	`284`	`"conditions": [`
`285`	`285`	`{`
`@@ -306,7 +306,7 @@ def test_toggles_no_match_rule_with_contains_action(mocker, config):`
`306`	`306`	`"feature_default_value": expected_value,`
`307`	`307`	`"rules": [`
`308`	`308`	`{`
`309`		`- "rule_name": "tenant id is contained in [6,2] ",`
	`309`	`+ "rule_name": "tenant id is contained in [8, 2]",`
`310`	`310`	`"value_when_applies": True,`
`311`	`311`	`"conditions": [`
`312`	`312`	`{`
`@@ -333,7 +333,7 @@ def test_multiple_features_enabled(mocker, config):`
`333`	`333`	`"feature_default_value": False,`
`334`	`334`	`"rules": [`
`335`	`335`	`{`
`336`		`- "rule_name": "tenant id is contained in [6,2] ",`
	`336`	`+ "rule_name": "tenant id is contained in [6, 2]",`
`337`	`337`	`"value_when_applies": True,`
`338`	`338`	`"conditions": [`
`339`	`339`	`{`
`@@ -366,7 +366,7 @@ def test_multiple_features_only_some_enabled(mocker, config):`
`366`	`366`	`"feature_default_value": False,`
`367`	`367`	`"rules": [`
`368`	`368`	`{`
`369`		`- "rule_name": "tenant id is contained in [6,2] ",`
	`369`	`+ "rule_name": "tenant id is contained in [6, 2]",`
`370`	`370`	`"value_when_applies": True,`
`371`	`371`	`"conditions": [`
`372`	`372`	`{`
Original file line number	Diff line number	Diff line change
`@@ -33,11 +33,13 @@ def test_invalid_features_dict():`
`33`	`33`
`34`	`34`	`schema = []`
`35`	`35`	`# invalid type`
	`36`	`+ validator = SchemaValidator(schema)`
`36`	`37`	`with pytest.raises(ConfigurationError):`
`37`	`38`	`validator.validate()`
`38`	`39`
`39`	`40`	`# invalid features key`
`40`	`41`	`schema = {FEATURES_KEY: []}`
	`42`	`+ validator = SchemaValidator(schema)`
`41`	`43`	`with pytest.raises(ConfigurationError):`
`42`	`44`	`validator.validate()`
`43`	`45`
`@@ -57,33 +59,38 @@ def test_invalid_feature_dict():`
`57`	`59`
`58`	`60`	`# empty feature dict`
`59`	`61`	`schema = {FEATURES_KEY: {"my_feature": {}}}`
	`62`	`+ validator = SchemaValidator(schema)`
`60`	`63`	`with pytest.raises(ConfigurationError):`
`61`	`64`	`validator.validate()`
`62`	`65`
`63`	`66`	`# invalid FEATURE_DEFAULT_VAL_KEY type, not boolean`
`64`	`67`	`schema = {FEATURES_KEY: {"my_feature": {FEATURE_DEFAULT_VAL_KEY: "False"}}}`
	`68`	`+ validator = SchemaValidator(schema)`
`65`	`69`	`with pytest.raises(ConfigurationError):`
`66`	`70`	`validator.validate()`
`67`	`71`
`68`	`72`	`# invalid FEATURE_DEFAULT_VAL_KEY type, not boolean #2`
`69`	`73`	`schema = {FEATURES_KEY: {"my_feature": {FEATURE_DEFAULT_VAL_KEY: 5}}}`
	`74`	`+ validator = SchemaValidator(schema)`
`70`	`75`	`with pytest.raises(ConfigurationError):`
`71`	`76`	`validator.validate()`
`72`	`77`
`73`	`78`	`# invalid rules type, not list`
`74`	`79`	`schema = {FEATURES_KEY: {"my_feature": {FEATURE_DEFAULT_VAL_KEY: False, RULES_KEY: "4"}}}`
	`80`	`+ validator = SchemaValidator(schema)`
`75`	`81`	`with pytest.raises(ConfigurationError):`
`76`	`82`	`validator.validate()`
`77`	`83`
`78`	`84`
`79`	`85`	`def test_valid_feature_dict():`
`80`		`- # no rules list at all`
`81`		`- schema = {FEATURES_KEY: {"my_feature": {FEATURE_DEFAULT_VAL_KEY: False}}}`
	`86`	`+ # empty rules list`
	`87`	`+ schema = {FEATURES_KEY: {"my_feature": {FEATURE_DEFAULT_VAL_KEY: False, RULES_KEY: []}}}`
`82`	`88`	`validator = SchemaValidator(schema)`
`83`	`89`	`validator.validate()`
`84`	`90`
`85`		`- # empty rules list`
`86`		`- schema = {FEATURES_KEY: {"my_feature": {FEATURE_DEFAULT_VAL_KEY: False, RULES_KEY: []}}}`
	`91`	`+ # no rules list at all`
	`92`	`+ schema = {FEATURES_KEY: {"my_feature": {FEATURE_DEFAULT_VAL_KEY: False}}}`
	`93`	`+ validator = SchemaValidator(schema)`
`87`	`94`	`validator.validate()`
`88`	`95`
`89`	`96`
`@@ -118,6 +125,7 @@ def test_invalid_rule():`
`118`	`125`	`}`
`119`	`126`	`}`
`120`	`127`	`}`
	`128`	`+ validator = SchemaValidator(schema)`
`121`	`129`	`with pytest.raises(ConfigurationError):`
`122`	`130`	`validator.validate()`
`123`	`131`
`@@ -135,6 +143,7 @@ def test_invalid_rule():`
`135`	`143`	`}`
`136`	`144`	`}`
`137`	`145`	`}`
	`146`	`+ validator = SchemaValidator(schema)`
`138`	`147`	`with pytest.raises(ConfigurationError):`
`139`	`148`	`validator.validate()`
`140`	`149`
`@@ -149,6 +158,7 @@ def test_invalid_rule():`
`149`	`158`	`}`
`150`	`159`	`}`
`151`	`160`	`}`
	`161`	`+ validator = SchemaValidator(schema)`
`152`	`162`	`with pytest.raises(ConfigurationError):`
`153`	`163`	`validator.validate()`
`154`	`164`
`@@ -163,6 +173,7 @@ def test_invalid_rule():`
`163`	`173`	`}`
`164`	`174`	`}`
`165`	`175`	`}`
	`176`	`+ validator = SchemaValidator(schema)`
`166`	`177`	`with pytest.raises(ConfigurationError):`
`167`	`178`	`validator.validate()`
`168`	`179`
`@@ -202,6 +213,7 @@ def test_invalid_condition():`
`202`	`213`	`}`
`203`	`214`	`}`
`204`	`215`	`}`
	`216`	`+ validator = SchemaValidator(schema)`
`205`	`217`	`with pytest.raises(ConfigurationError):`
`206`	`218`	`validator.validate()`
`207`	`219`
`@@ -224,6 +236,7 @@ def test_invalid_condition():`
`224`	`236`	`}`
`225`	`237`	`}`
`226`	`238`	`}`
	`239`	`+ validator = SchemaValidator(schema)`
`227`	`240`	`with pytest.raises(ConfigurationError):`
`228`	`241`	`validator.validate()`
`229`	`242`