chore: move serialization/hashing to test util

Author: heitorlessa

tests/functional/idempotency/conftest.py

@@ -1,5 +1,4 @@
 import datetime
-import hashlib
 import json
 from collections import namedtuple
 from decimal import Decimal
@@ -11,20 +10,15 @@
 from botocore.config import Config
 from jmespath import functions
 
-from aws_lambda_powertools.shared.json_encoder import Encoder
 from aws_lambda_powertools.utilities.idempotency import DynamoDBPersistenceLayer
 from aws_lambda_powertools.utilities.idempotency.idempotency import IdempotencyConfig
 from aws_lambda_powertools.utilities.jmespath_utils import extract_data_from_envelope
 from aws_lambda_powertools.utilities.validation import envelopes
-from tests.functional.utils import load_event
+from tests.functional.utils import hash_idempotency_key, json_serialize, load_event
 
 TABLE_NAME = "TEST_TABLE"
 
 
-def serialize(data):
-    return json.dumps(data, sort_keys=True, cls=Encoder)
-
-
 @pytest.fixture(scope="module")
 def config() -> Config:
     return Config(region_name="us-east-1")
@@ -66,12 +60,12 @@ def lambda_response():
 
 @pytest.fixture(scope="module")
 def serialized_lambda_response(lambda_response):
-    return serialize(lambda_response)
+    return json_serialize(lambda_response)
 
 
 @pytest.fixture(scope="module")
 def deserialized_lambda_response(lambda_response):
-    return json.loads(serialize(lambda_response))
+    return json.loads(json_serialize(lambda_response))
 
 
 @pytest.fixture
@@ -150,20 +144,20 @@ def expected_params_put_item_with_validation(hashed_idempotency_key, hashed_vali
 def hashed_idempotency_key(lambda_apigw_event, default_jmespath, lambda_context):
     compiled_jmespath = jmespath.compile(default_jmespath)
     data = compiled_jmespath.search(lambda_apigw_event)
-    return "test-func.lambda_handler#" + hashlib.md5(serialize(data).encode()).hexdigest()
+    return "test-func.lambda_handler#" + hash_idempotency_key(data)
 
 
 @pytest.fixture
 def hashed_idempotency_key_with_envelope(lambda_apigw_event):
     event = extract_data_from_envelope(
         data=lambda_apigw_event, envelope=envelopes.API_GATEWAY_HTTP, jmespath_options={}
     )
-    return "test-func.lambda_handler#" + hashlib.md5(serialize(event).encode()).hexdigest()
+    return "test-func.lambda_handler#" + hash_idempotency_key(event)
 
 
 @pytest.fixture
 def hashed_validation_key(lambda_apigw_event):
-    return hashlib.md5(serialize(lambda_apigw_event["requestContext"]).encode()).hexdigest()
+    return hash_idempotency_key(lambda_apigw_event["requestContext"])
 
 
 @pytest.fixture

tests/functional/idempotency/test_idempotency.py

@@ -1,6 +1,4 @@
 import copy
-import hashlib
-import json
 import sys
 from hashlib import md5
 from unittest.mock import MagicMock
@@ -24,8 +22,7 @@
 from aws_lambda_powertools.utilities.idempotency.idempotency import idempotent, idempotent_function
 from aws_lambda_powertools.utilities.idempotency.persistence.base import BasePersistenceLayer, DataRecord
 from aws_lambda_powertools.utilities.validation import envelopes, validator
-from tests.functional.idempotency.conftest import serialize
-from tests.functional.utils import load_event
+from tests.functional.utils import hash_idempotency_key, json_serialize, load_event
 
 TABLE_NAME = "TEST_TABLE"
 
@@ -753,7 +750,7 @@ def test_default_no_raise_on_missing_idempotency_key(
     hashed_key = persistence_store._get_hashed_idempotency_key({})
 
     # THEN return the hash of None
-    expected_value = f"test-func.{function_name}#" + md5(serialize(None).encode()).hexdigest()
+    expected_value = f"test-func.{function_name}#" + md5(json_serialize(None).encode()).hexdigest()
     assert expected_value == hashed_key
 
 
@@ -797,7 +794,7 @@ def test_jmespath_with_powertools_json(
     expected_value = [sub_attr_value, static_pk_value]
     api_gateway_proxy_event = {
         "requestContext": {"authorizer": {"claims": {"sub": sub_attr_value}}},
-        "body": serialize({"id": static_pk_value}),
+        "body": json_serialize({"id": static_pk_value}),
     }
 
     # WHEN calling _get_hashed_idempotency_key
@@ -881,9 +878,7 @@ def _delete_record(self, data_record: DataRecord) -> None:
 def test_idempotent_lambda_event_source(lambda_context):
     # Scenario to validate that we can use the event_source decorator before or after the idempotent decorator
     mock_event = load_event("apiGatewayProxyV2Event.json")
-    persistence_layer = MockPersistenceLayer(
-        "test-func.lambda_handler#" + hashlib.md5(serialize(mock_event).encode()).hexdigest()
-    )
+    persistence_layer = MockPersistenceLayer("test-func.lambda_handler#" + hash_idempotency_key(mock_event))
     expected_result = {"message": "Foo"}
 
     # GIVEN an event_source decorator
@@ -903,9 +898,8 @@ def lambda_handler(event, _):
 def test_idempotent_function():
     # Scenario to validate we can use idempotent_function with any function
     mock_event = {"data": "value"}
-    persistence_layer = MockPersistenceLayer(
-        "test-func.record_handler#" + hashlib.md5(serialize(mock_event).encode()).hexdigest()
-    )
+    idempotency_key = "test-func.record_handler#" + hash_idempotency_key(mock_event)
+    persistence_layer = MockPersistenceLayer(expected_idempotency_key=idempotency_key)
     expected_result = {"message": "Foo"}
 
     @idempotent_function(persistence_store=persistence_layer, data_keyword_argument="record")
@@ -922,9 +916,8 @@ def test_idempotent_function_arbitrary_args_kwargs():
     # Scenario to validate we can use idempotent_function with a function
     # with an arbitrary number of args and kwargs
     mock_event = {"data": "value"}
-    persistence_layer = MockPersistenceLayer(
-        "test-func.record_handler#" + hashlib.md5(serialize(mock_event).encode()).hexdigest()
-    )
+    idempotency_key = "test-func.record_handler#" + hash_idempotency_key(mock_event)
+    persistence_layer = MockPersistenceLayer(expected_idempotency_key=idempotency_key)
     expected_result = {"message": "Foo"}
 
     @idempotent_function(persistence_store=persistence_layer, data_keyword_argument="record")
@@ -939,9 +932,8 @@ def record_handler(arg_one, arg_two, record, is_record):
 
 def test_idempotent_function_invalid_data_kwarg():
     mock_event = {"data": "value"}
-    persistence_layer = MockPersistenceLayer(
-        "test-func.record_handler#" + hashlib.md5(serialize(mock_event).encode()).hexdigest()
-    )
+    idempotency_key = "test-func.record_handler#" + hash_idempotency_key(mock_event)
+    persistence_layer = MockPersistenceLayer(expected_idempotency_key=idempotency_key)
     expected_result = {"message": "Foo"}
     keyword_argument = "payload"
 
@@ -958,9 +950,8 @@ def record_handler(record):
 
 def test_idempotent_function_arg_instead_of_kwarg():
     mock_event = {"data": "value"}
-    persistence_layer = MockPersistenceLayer(
-        "test-func.record_handler#" + hashlib.md5(serialize(mock_event).encode()).hexdigest()
-    )
+    idempotency_key = "test-func.record_handler#" + hash_idempotency_key(mock_event)
+    persistence_layer = MockPersistenceLayer(expected_idempotency_key=idempotency_key)
     expected_result = {"message": "Foo"}
     keyword_argument = "record"
 
@@ -978,18 +969,15 @@ def record_handler(record):
 def test_idempotent_function_and_lambda_handler(lambda_context):
     # Scenario to validate we can use both idempotent_function and idempotent decorators
     mock_event = {"data": "value"}
-    persistence_layer = MockPersistenceLayer(
-        "test-func.record_handler#" + hashlib.md5(serialize(mock_event).encode()).hexdigest()
-    )
+    idempotency_key = "test-func.record_handler#" + hash_idempotency_key(mock_event)
+    persistence_layer = MockPersistenceLayer(expected_idempotency_key=idempotency_key)
     expected_result = {"message": "Foo"}
 
     @idempotent_function(persistence_store=persistence_layer, data_keyword_argument="record")
     def record_handler(record):
         return expected_result
 
-    persistence_layer = MockPersistenceLayer(
-        "test-func.lambda_handler#" + hashlib.md5(serialize(mock_event).encode()).hexdigest()
-    )
+    persistence_layer = MockPersistenceLayer("test-func.lambda_handler#" + hash_idempotency_key(mock_event))
 
     @idempotent(persistence_store=persistence_layer)
     def lambda_handler(event, _):
@@ -1010,18 +998,16 @@ def test_idempotent_data_sorting():
     # Scenario to validate same data in different order hashes to the same idempotency key
     data_one = {"data": "test message 1", "more_data": "more data 1"}
     data_two = {"more_data": "more data 1", "data": "test message 1"}
-
+    idempotency_key = "test-func.dummy#" + hash_idempotency_key(data_one)
     # Assertion will happen in MockPersistenceLayer
-    persistence_layer = MockPersistenceLayer(
-        "test-func.dummy#" + hashlib.md5(json.dumps(data_one).encode()).hexdigest()
-    )
+    persistence_layer = MockPersistenceLayer(expected_idempotency_key=idempotency_key)
 
     # GIVEN
     @idempotent_function(data_keyword_argument="payload", persistence_store=persistence_layer)
     def dummy(payload):
         return {"message": "hello"}
 
-    # WHEN
+    # WHEN/THEN assertion will happen at MockPersistenceLayer
     dummy(payload=data_two)
 
 
@@ -1120,10 +1106,8 @@ def test_idempotent_function_dataclass_with_jmespath():
     dataclasses = get_dataclasses_lib()
     config = IdempotencyConfig(event_key_jmespath="transaction_id", use_local_cache=True)
     mock_event = {"customer_id": "fake", "transaction_id": "fake-id"}
-    persistence_layer = MockPersistenceLayer(
-        expected_idempotency_key="test-func.collect_payment#"
-        + hashlib.md5(serialize(mock_event["transaction_id"]).encode()).hexdigest()
-    )
+    idempotency_key = "test-func.collect_payment#" + hash_idempotency_key(mock_event["transaction_id"])
+    persistence_layer = MockPersistenceLayer(expected_idempotency_key=idempotency_key)
 
     @dataclasses.dataclass
     class Payment:
@@ -1147,10 +1131,8 @@ def test_idempotent_function_pydantic_with_jmespath():
     # GIVEN
     config = IdempotencyConfig(event_key_jmespath="transaction_id", use_local_cache=True)
     mock_event = {"customer_id": "fake", "transaction_id": "fake-id"}
-    persistence_layer = MockPersistenceLayer(
-        expected_idempotency_key="test-func.collect_payment#"
-        + hashlib.md5(serialize(mock_event["transaction_id"]).encode()).hexdigest()
-    )
+    idempotency_key = "test-func.collect_payment#" + hash_idempotency_key(mock_event["transaction_id"])
+    persistence_layer = MockPersistenceLayer(expected_idempotency_key=idempotency_key)
 
     class Payment(BaseModel):
         customer_id: str

tests/functional/utils.py

@@ -1,8 +1,11 @@
 import base64
+import hashlib
 import json
 from pathlib import Path
 from typing import Any
 
+from aws_lambda_powertools.shared.json_encoder import Encoder
+
 
 def load_event(file_name: str) -> Any:
     path = Path(str(Path(__file__).parent.parent) + "/events/" + file_name)
@@ -15,3 +18,12 @@ def str_to_b64(data: str) -> str:
 
 def b64_to_str(data: str) -> str:
     return base64.b64decode(data.encode()).decode("utf-8")
+
+
+def json_serialize(data):
+    return json.dumps(data, sort_keys=True, cls=Encoder)
+
+
+def hash_idempotency_key(data: Any):
+    """Serialize data to JSON, encode, and hash it for idempotency key"""
+    return hashlib.md5(json_serialize(data).encode()).hexdigest()