Removing unnecessary code

Author: leandrodamascena

aws_lambda_powertools/utilities/data_masking/base.py

@@ -450,9 +450,6 @@ def _call_action(
         return fields[field_name]
 
     def _normalize_data_to_parse(self, fields: list, data: str | dict) -> dict:
-        if not fields:
-            raise ValueError("No fields specified.")
-
         if isinstance(data, str):
             # Parse JSON string as dictionary
             data_parsed = self.json_deserializer(data)

aws_lambda_powertools/utilities/data_masking/provider/base.py

@@ -89,7 +89,7 @@ def erase(
                 return DATA_MASKING_STRING
 
         if isinstance(data, (str, int, float)):
-            result = self._mask_primitive(str(data), dynamic_mask, custom_mask, regex_pattern, mask_format, **kwargs)
+            result = self._mask_primitive(str(data), dynamic_mask, custom_mask, regex_pattern, mask_format)
         elif isinstance(data, dict):
             result = self._mask_dict(
                 data,
@@ -98,7 +98,6 @@ def erase(
                 regex_pattern,
                 mask_format,
                 masking_rules,
-                **kwargs,
             )
         elif isinstance(data, (list, tuple, set)):
             result = self._mask_iterable(
@@ -108,7 +107,6 @@ def erase(
                 regex_pattern,
                 mask_format,
                 masking_rules,
-                **kwargs,
             )
 
         return result
@@ -120,14 +118,13 @@ def _mask_primitive(
         custom_mask: str | None,
         regex_pattern: str | None,
         mask_format: str | None,
-        **kwargs,
     ) -> str:
         if regex_pattern and mask_format:
             return self._regex_mask(data, regex_pattern, mask_format)
         elif custom_mask:
             return self._pattern_mask(data, custom_mask)
-        elif dynamic_mask:
-            return self._custom_erase(data)
+
+        return self._custom_erase(data)
 
     def _mask_dict(
         self,
@@ -137,23 +134,18 @@ def _mask_dict(
         regex_pattern: str | None,
         mask_format: str | None,
         masking_rules: dict | None,
-        **kwargs,
     ) -> dict:
-        if masking_rules:
-            return self._apply_masking_rules(data, masking_rules)
-        else:
-            return {
-                k: self.erase(
-                    v,
-                    dynamic_mask=dynamic_mask,
-                    custom_mask=custom_mask,
-                    regex_pattern=regex_pattern,
-                    mask_format=mask_format,
-                    masking_rules=masking_rules,
-                    **kwargs,
-                )
-                for k, v in data.items()
-            }
+        return {
+            k: self.erase(
+                v,
+                dynamic_mask=dynamic_mask,
+                custom_mask=custom_mask,
+                regex_pattern=regex_pattern,
+                mask_format=mask_format,
+                masking_rules=masking_rules,
+            )
+            for k, v in data.items()
+        }
 
     def _mask_iterable(
         self,
@@ -163,7 +155,6 @@ def _mask_iterable(
         regex_pattern: str | None,
         mask_format: str | None,
         masking_rules: dict | None,
-        **kwargs,
     ) -> list | tuple | set:
         masked_data = [
             self.erase(
@@ -173,19 +164,11 @@ def _mask_iterable(
                 regex_pattern=regex_pattern,
                 mask_format=mask_format,
                 masking_rules=masking_rules,
-                **kwargs,
             )
             for item in data
         ]
         return type(data)(masked_data)
 
-    def _apply_masking_rules(self, data: dict, masking_rules: dict) -> Any:
-        """Apply masking rules to dictionary data."""
-        return {
-            key: self.erase(str(value), **masking_rules[key]) if key in masking_rules else str(value)
-            for key, value in data.items()
-        }
-
     def _pattern_mask(self, data: str, pattern: str) -> str:
         """Apply pattern masking to string data."""
         return pattern[: len(data)] if len(pattern) >= len(data) else pattern

tests/functional/data_masking/required_dependencies/test_erase_data_masking.py

@@ -232,6 +232,24 @@ def test_regex_mask(data_masker):
     assert result == "Hello! My name is XXXX XXXX"
 
 
+def test_regex_mask_with_cache(data_masker):
+    # GIVEN a str data type
+    data = "Hello! My name is John Doe"
+    data1 = "Hello! My name is John Xix"
+
+    # WHEN erase is called with regex pattern and mask format
+    regex_pattern = r"\b[A-Z][a-z]+ [A-Z][a-z]+\b"
+    mask_format = "XXXX XXXX"
+
+    # WHEN erasing twice to check the regex compiled and stored in the cache
+    result = data_masker.erase(data, regex_pattern=regex_pattern, mask_format=mask_format)
+    result1 = data_masker.erase(data1, regex_pattern=regex_pattern, mask_format=mask_format)
+
+    # THEN the result is the regex part masked by the masked format
+    assert result == "Hello! My name is XXXX XXXX"
+    assert result1 == "Hello! My name is XXXX XXXX"
+
+
 def test_erase_json_dict_with_fields_and_masks(data_masker):
     # GIVEN the data type is a json representation of a dictionary
     data = json.dumps(
@@ -353,6 +371,39 @@ def test_erase_dictionary_with_masking_rules(data_masker):
     }
 
 
+def test_erase_dictionary_with_masking_rules_with_list(data_masker):
+    # GIVEN a dictionary with nested sensitive data
+    data = {"user": {"name": ["leandro", "powertools"]}}
+
+    # AND masking rules for specific fields
+    masking_rules = {"user.name": {"custom_mask": "NO-NAME"}}
+
+    # WHEN erase is called with masking rules
+    result = data_masker.erase(data, masking_rules=masking_rules)
+
+    # THEN only the specified fields should be masked
+    assert result == {
+        "user": {
+            "name": "NO-NAME",
+        },
+    }
+
+
+def test_erase_list_with_custom_mask(data_masker):
+    # GIVEN a dictionary with nested sensitive data
+    data = {"user": {"name": ["leandro", "powertools"]}}
+
+    # WHEN erase is called with masking rules
+    result = data_masker.erase(data, fields=["user.name"], dynamic_mask=True)
+
+    # THEN only the specified fields should be masked
+    assert result == {
+        "user": {
+            "name": ["*******", "**********"],
+        },
+    }
+
+
 def test_erase_dictionary_with_global_mask(data_masker):
     # GIVEN a dictionary with sensitive data
     data = {"user": {"name": "John Doe", "ssn": "123-45-6789"}}