Addressing Heitor's feedback

Author: leandrodamascena

aws_lambda_powertools/event_handler/appsync.py

@@ -7,6 +7,7 @@
 from aws_lambda_powertools.event_handler.graphql_appsync.router import Router
 from aws_lambda_powertools.utilities.data_classes import AppSyncResolverEvent
 from aws_lambda_powertools.utilities.typing import LambdaContext
+from aws_lambda_powertools.warnings import PowertoolsUserWarning
 
 logger = logging.getLogger(__name__)
 
@@ -280,6 +281,7 @@ def _call_batch_resolver(self, event: List[dict], data_model: Type[AppSyncResolv
                 f"Both synchronous and asynchronous resolvers found for the same event and field."
                 f"The synchronous resolver takes precedence. Executing: {resolver['func'].__name__}",
                 stacklevel=2,
+                category=PowertoolsUserWarning,
             )
 
         if resolver:

tests/functional/event_handler/required_dependencies/test_appsync.py

@@ -8,6 +8,7 @@
 from aws_lambda_powertools.event_handler.graphql_appsync.router import Router
 from aws_lambda_powertools.utilities.data_classes import AppSyncResolverEvent
 from aws_lambda_powertools.utilities.typing import LambdaContext
+from aws_lambda_powertools.warnings import PowertoolsUserWarning
 from tests.functional.utils import load_event
 
 
@@ -303,8 +304,106 @@ def test_include_router_merges_context():
     assert app.context == router.context
 
 
+def test_resolve_batch_processing_with_related_events():
+    # GIVEN An event with multiple requests to fetch related posts for different post IDs.
+    event = [
+        {
+            "arguments": {},
+            "identity": "None",
+            "source": {
+                "post_id": "3",
+                "title": "Third book",
+            },
+            "info": {
+                "selectionSetList": [
+                    "title",
+                ],
+                "selectionSetGraphQL": "{\n  title\n}",
+                "fieldName": "relatedPosts",
+                "parentTypeName": "Post",
+            },
+        },
+        {
+            "arguments": {},
+            "identity": "None",
+            "source": {
+                "post_id": "4",
+                "title": "Fifth book",
+            },
+            "info": {
+                "selectionSetList": [
+                    "title",
+                ],
+                "selectionSetGraphQL": "{\n  title\n}",
+                "fieldName": "relatedPosts",
+                "parentTypeName": "Post",
+            },
+        },
+        {
+            "arguments": {},
+            "identity": "None",
+            "source": {
+                "post_id": "1",
+                "title": "First book",
+            },
+            "info": {
+                "selectionSetList": [
+                    "title",
+                ],
+                "selectionSetGraphQL": "{\n  title\n}",
+                "fieldName": "relatedPosts",
+                "parentTypeName": "Post",
+            },
+        },
+    ]
+
+    # GIVEN A dictionary of posts and a dictionary of related posts.
+    posts = {
+        "1": {
+            "post_id": "1",
+            "title": "First book",
+        },
+        "2": {
+            "post_id": "2",
+            "title": "Second book",
+        },
+        "3": {
+            "post_id": "3",
+            "title": "Third book",
+        },
+        "4": {
+            "post_id": "4",
+            "title": "Fourth book",
+        },
+    }
+
+    posts_related = {
+        "1": [posts["2"]],
+        "2": [posts["3"], posts["4"], posts["1"]],
+        "3": [posts["2"], posts["1"]],
+        "4": [posts["3"], posts["1"]],
+    }
+
+    app = AppSyncResolver()
+
+    @app.batch_resolver(type_name="Post", field_name="relatedPosts")
+    def related_posts(event: AppSyncResolverEvent) -> Optional[list]:
+        return posts_related[event.source["post_id"]]
+
+    # WHEN related_posts function, which is the batch resolver, is called with the event.
+    result = app.resolve(event, LambdaContext())
+
+    # THEN the result must be a list of related posts
+    assert result == [
+        posts_related["3"],
+        posts_related["4"],
+        posts_related["1"],
+    ]
+
+
 # Batch resolver tests
-def test_resolve_batch_processing():
+def test_resolve_batch_processing_with_simple_queries():
+    # GIVEN a list of events representing GraphQL queries for listing locations
     event = [
         {
             "typeName": "Query",
@@ -346,11 +445,12 @@ def test_resolve_batch_processing():
 
     app = AppSyncResolver()
 
+    # WHEN the batch resolver for the listLocations field is defined
     @app.batch_resolver(field_name="listLocations")
     def create_something(event: AppSyncResolverEvent) -> Optional[list]:  # noqa AA03 VNE003
         return event.source["id"] if event.source else None
 
-    # Call the implicit handler
+    # THEN the resolver should correctly process the batch of queries
     result = app.resolve(event, LambdaContext())
     assert result == [appsync_event["source"]["id"] for appsync_event in event]
 
@@ -359,6 +459,7 @@ def create_something(event: AppSyncResolverEvent) -> Optional[list]:  # noqa AA0
 
 
 def test_resolve_batch_processing_with_raise_on_exception():
+    # GIVEN a list of events representing GraphQL queries for listing locations
     event = [
         {
             "typeName": "Query",
@@ -400,16 +501,18 @@ def test_resolve_batch_processing_with_raise_on_exception():
 
     app = AppSyncResolver()
 
+    # WHEN the sync batch resolver for the 'listLocations' field is defined with raise_on_error=True
     @app.batch_resolver(field_name="listLocations", raise_on_error=True)
     def create_something(event: AppSyncResolverEvent) -> Optional[list]:  # noqa AA03 VNE003
         raise RuntimeError
 
-    # Call the implicit handler
+    # THEN the resolver should raise a RuntimeError when processing the batch of queries
     with pytest.raises(RuntimeError):
         app.resolve(event, LambdaContext())
 
 
 def test_async_resolve_batch_processing_with_raise_on_exception():
+    # GIVEN a list of events representing GraphQL queries for listing locations
     event = [
         {
             "typeName": "Query",
@@ -451,11 +554,12 @@ def test_async_resolve_batch_processing_with_raise_on_exception():
 
     app = AppSyncResolver()
 
+    # WHEN the async batch resolver for the 'listLocations' field is defined with raise_on_error=True
     @app.async_batch_resolver(field_name="listLocations", raise_on_error=True)
     async def create_something(event: AppSyncResolverEvent) -> Optional[list]:  # noqa AA03 VNE003
         raise RuntimeError
 
-    # Call the implicit handler
+    # THEN the resolver should raise a RuntimeError when processing the batch of queries
     with pytest.raises(RuntimeError):
         app.resolve(event, LambdaContext())
 
@@ -515,6 +619,7 @@ def create_something(event: AppSyncResolverEvent) -> Optional[list]:  # noqa AA0
 
 
 def test_resolve_async_batch_processing_without_exception():
+    # GIVEN a list of events representing GraphQL queries for listing locations
     event = [
         {
             "typeName": "Query",
@@ -556,16 +661,16 @@ def test_resolve_async_batch_processing_without_exception():
 
     app = AppSyncResolver()
 
+    # WHEN the batch resolver for the 'listLocations' field is defined with raise_on_error=False
     @app.async_batch_resolver(field_name="listLocations", raise_on_error=False)
     async def create_something(event: AppSyncResolverEvent) -> Optional[list]:  # noqa AA03 VNE003
         raise RuntimeError
 
-    # Call the implicit handler
     result = app.resolve(event, LambdaContext())
-    assert result == [None, None, None]
 
-    assert app.current_batch_event and len(app.current_batch_event) == len(event)
-    assert not app.current_event
+    # THEN the resolver should return None for each event in the batch
+    assert len(app.current_batch_event) == len(event)
+    assert result == [None, None, None]
 
 
 def test_resolver_batch_with_resolver_not_found():
@@ -596,7 +701,7 @@ def get_locations(event: AppSyncResolverEvent, name: str) -> str:
 
     app.include_router(router)
 
-    # THEN must fail with ValueError
+    # THEN must fail with ResolverNotFoundError
     with pytest.raises(ResolverNotFoundError, match="No resolver found for.*"):
         app.resolve(mock_event1, LambdaContext())
 
@@ -633,27 +738,27 @@ async def get_locations_async(event: AppSyncResolverEvent, name: str) -> str:
 
     app.include_router(router)
 
-    # THEN must fail with ValueError
-    with pytest.warns(UserWarning, match="Both synchronous and asynchronous resolvers*"):
+    # THEN must raise a PowertoolsUserWarning
+    with pytest.warns(PowertoolsUserWarning, match="Both synchronous and asynchronous resolvers*"):
         app.resolve(mock_event1, LambdaContext())
 
 
-def test_resolver_include_batch_resolver():
-    # GIVEN
+def test_batch_resolver_with_router():
+    # GIVEN an AppSyncResolver and a Router instance
     app = AppSyncResolver()
     router = Router()
 
     @router.batch_resolver(type_name="Query", field_name="listLocations")
     def get_locations(event: AppSyncResolverEvent, name: str) -> str:
-        return "get_locations#" + name + "#" + event.source["id"]
+        return f"get_locations#{name}#" + event.source["id"]
 
-    @app.batch_resolver(field_name="listLocations2")
+    @router.batch_resolver(field_name="listLocations2")
     def get_locations2(event: AppSyncResolverEvent, name: str) -> str:
-        return "get_locations2#" + name + "#" + event.source["id"]
+        return f"get_locations2#{name}#" + event.source["id"]
 
+    # WHEN we include the routes
     app.include_router(router)
 
-    # WHEN
     mock_event1 = [
         {
             "typeName": "Query",
@@ -685,12 +790,13 @@ def get_locations2(event: AppSyncResolverEvent, name: str) -> str:
     result1 = app.resolve(mock_event1, LambdaContext())
     result2 = app.resolve(mock_event2, LambdaContext())
 
-    # THEN
+    # THEN the resolvers should return the expected results
     assert result1 == ["get_locations#value#1"]
     assert result2 == ["get_locations2#value#2"]
 
 
 def test_resolve_async_batch_processing():
+    # GIVEN a list of events representing GraphQL queries for listing locations
     event = [
         {
             "typeName": "Query",
@@ -732,19 +838,20 @@ def test_resolve_async_batch_processing():
 
     app = AppSyncResolver()
 
+    # WHEN the async batch resolver for the 'listLocations' field is defined
     @app.async_batch_resolver(field_name="listLocations")
     async def create_something(event: AppSyncResolverEvent) -> Optional[list]:
         return event.source["id"] if event.source else None
 
-    # Call the implicit handler
+    # THEN the resolver should correctly process the batch of queries asynchronously
     result = app.resolve(event, LambdaContext())
     assert result == [appsync_event["source"]["id"] for appsync_event in event]
 
     assert app.current_batch_event and len(app.current_batch_event) == len(event)
 
 
 def test_resolve_async_batch_and_sync_singular_processing():
-    # GIVEN
+    # GIVEN a router with an async batch resolver for 'listLocations' and a sync singular resolver for 'listLocation'
     app = AppSyncResolver()
     router = Router()
 
@@ -758,7 +865,7 @@ def get_location(name: str) -> str:
 
     app.include_router(router)
 
-    # WHEN
+    # WHEN resolving a batch of events for async 'listLocations' and a singular event for 'listLocation'
     mock_event1 = [
         {
             "typeName": "Query",
@@ -778,7 +885,7 @@ def get_location(name: str) -> str:
     result1 = app.resolve(mock_event1, LambdaContext())
     result2 = app.resolve(mock_event2, LambdaContext())
 
-    # THEN
+    # THEN the resolvers should return the expected results
     assert result1 == ["get_locations#value#1"]
     assert result2 == "get_location#value"
 
@@ -790,11 +897,11 @@ def test_async_resolver_include_batch_resolver():
 
     @router.async_batch_resolver(type_name="Query", field_name="listLocations")
     async def get_locations(event: AppSyncResolverEvent, name: str) -> str:
-        return "get_locations#" + name + "#" + event.source["id"]
+        return f"get_locations#{name}#" + event.source["id"]
 
     @app.async_batch_resolver(field_name="listLocations2")
     async def get_locations2(event: AppSyncResolverEvent, name: str) -> str:
-        return "get_locations2#" + name + "#" + event.source["id"]
+        return f"get_locations2#{name}#" + event.source["id"]
 
     app.include_router(router)