Merge remote-tracking branch 'michaelbrewer/docs/router' into docs/router

* michaelbrewer/docs/router:
  feat(data-classes): ActiveMQ and RabbitMQ support (aws-powertools#770)
  feat(appsync): add Router to allow large resolver composition (aws-powertools#776)
  chore(deps-dev): bump mkdocs-material from 7.3.3 to 7.3.5 (aws-powertools#781)
  chore(deps-dev): bump flake8-isort from 4.0.0 to 4.1.1 (aws-powertools#785)
  chore(deps): bump urllib3 from 1.26.4 to 1.26.5 (aws-powertools#787)
  chore(deps-dev): bump flake8-eradicate from 1.1.0 to 1.2.0 (aws-powertools#784)
  chore(deps): bump boto3 from 1.18.61 to 1.19.6 (aws-powertools#783)
  chore(deps-dev): bump pytest-asyncio from 0.15.1 to 0.16.0 (aws-powertools#782)
  docs: fix indentation of SAM snippets in install section (aws-powertools#778)
  Fix middleware sample (aws-powertools#772)
  Removed unused import, added typing imports, fixed typo in example. (aws-powertools#774)
  Fix middleware sample (aws-powertools#772)
  Removed unused import, added typing imports, fixed typo in example. (aws-powertools#774)
  Update docs/core/event_handler/api_gateway.md

# Conflicts:
#	docs/core/event_handler/api_gateway.md

Author: heitorlessa

aws_lambda_powertools/event_handler/appsync.py

@@ -1,4 +1,5 @@
 import logging
+from abc import ABC
 from typing import Any, Callable, Optional, Type, TypeVar
 
 from aws_lambda_powertools.utilities.data_classes import AppSyncResolverEvent
@@ -9,7 +10,33 @@
 AppSyncResolverEventT = TypeVar("AppSyncResolverEventT", bound=AppSyncResolverEvent)
 
 
-class AppSyncResolver:
+class BaseRouter(ABC):
+    current_event: AppSyncResolverEventT  # type: ignore[valid-type]
+    lambda_context: LambdaContext
+
+    def __init__(self):
+        self._resolvers: dict = {}
+
+    def resolver(self, type_name: str = "*", field_name: Optional[str] = None):
+        """Registers the resolver for field_name
+
+        Parameters
+        ----------
+        type_name : str
+            Type name
+        field_name : str
+            Field name
+        """
+
+        def register_resolver(func):
+            logger.debug(f"Adding resolver `{func.__name__}` for field `{type_name}.{field_name}`")
+            self._resolvers[f"{type_name}.{field_name}"] = {"func": func}
+            return func
+
+        return register_resolver
+
+
+class AppSyncResolver(BaseRouter):
     """
     AppSync resolver decorator
 
@@ -40,29 +67,8 @@ def common_field() -> str:
             return str(uuid.uuid4())
     """
 
-    current_event: AppSyncResolverEventT  # type: ignore[valid-type]
-    lambda_context: LambdaContext
-
     def __init__(self):
-        self._resolvers: dict = {}
-
-    def resolver(self, type_name: str = "*", field_name: Optional[str] = None):
-        """Registers the resolver for field_name
-
-        Parameters
-        ----------
-        type_name : str
-            Type name
-        field_name : str
-            Field name
-        """
-
-        def register_resolver(func):
-            logger.debug(f"Adding resolver `{func.__name__}` for field `{type_name}.{field_name}`")
-            self._resolvers[f"{type_name}.{field_name}"] = {"func": func}
-            return func
-
-        return register_resolver
+        super().__init__()
 
     def resolve(
         self, event: dict, context: LambdaContext, data_model: Type[AppSyncResolverEvent] = AppSyncResolverEvent
@@ -136,10 +142,10 @@ def lambda_handler(event, context):
         ValueError
             If we could not find a field resolver
         """
-        self.current_event = data_model(event)
-        self.lambda_context = context
-        resolver = self._get_resolver(self.current_event.type_name, self.current_event.field_name)
-        return resolver(**self.current_event.arguments)
+        BaseRouter.current_event = data_model(event)
+        BaseRouter.lambda_context = context
+        resolver = self._get_resolver(BaseRouter.current_event.type_name, BaseRouter.current_event.field_name)
+        return resolver(**BaseRouter.current_event.arguments)
 
     def _get_resolver(self, type_name: str, field_name: str) -> Callable:
         """Get resolver for field_name
@@ -167,3 +173,18 @@ def __call__(
     ) -> Any:
         """Implicit lambda handler which internally calls `resolve`"""
         return self.resolve(event, context, data_model)
+
+    def include_router(self, router: "Router") -> None:
+        """Adds all resolvers defined in a router
+
+        Parameters
+        ----------
+        router : Router
+            A router containing a dict of field resolvers
+        """
+        self._resolvers.update(router._resolvers)
+
+
+class Router(BaseRouter):
+    def __init__(self):
+        super().__init__()

aws_lambda_powertools/utilities/data_classes/active_mq_event.py

@@ -0,0 +1,125 @@
+import base64
+import json
+from typing import Any, Iterator, Optional
+
+from aws_lambda_powertools.utilities.data_classes.common import DictWrapper
+
+
+class ActiveMQMessage(DictWrapper):
+    @property
+    def message_id(self) -> str:
+        """Unique identifier for the message"""
+        return self["messageID"]
+
+    @property
+    def message_type(self) -> str:
+        return self["messageType"]
+
+    @property
+    def data(self) -> str:
+        return self["data"]
+
+    @property
+    def decoded_data(self) -> str:
+        """Decodes the data as a str"""
+        return base64.b64decode(self.data.encode()).decode()
+
+    @property
+    def json_data(self) -> Any:
+        """Parses the data as json"""
+        return json.loads(self.decoded_data)
+
+    @property
+    def connection_id(self) -> str:
+        return self["connectionId"]
+
+    @property
+    def redelivered(self) -> bool:
+        """true if the message is being resent to the consumer"""
+        return self["redelivered"]
+
+    @property
+    def timestamp(self) -> int:
+        """Time in milliseconds."""
+        return self["timestamp"]
+
+    @property
+    def broker_in_time(self) -> int:
+        """Time stamp (in milliseconds) for when the message arrived at the broker."""
+        return self["brokerInTime"]
+
+    @property
+    def broker_out_time(self) -> int:
+        """Time stamp (in milliseconds) for when the message left the broker."""
+        return self["brokerOutTime"]
+
+    @property
+    def destination_physicalname(self) -> str:
+        return self["destination"]["physicalname"]
+
+    @property
+    def delivery_mode(self) -> Optional[int]:
+        """persistent or non-persistent delivery"""
+        return self.get("deliveryMode")
+
+    @property
+    def correlation_id(self) -> Optional[str]:
+        """User defined correlation id"""
+        return self.get("correlationID")
+
+    @property
+    def reply_to(self) -> Optional[str]:
+        """User defined reply to"""
+        return self.get("replyTo")
+
+    @property
+    def get_type(self) -> Optional[str]:
+        """User defined message type"""
+        return self.get("type")
+
+    @property
+    def expiration(self) -> Optional[int]:
+        """Expiration attribute whose value is given in milliseconds"""
+        return self.get("expiration")
+
+    @property
+    def priority(self) -> Optional[int]:
+        """
+        JMS defines a ten-level priority value, with 0 as the lowest priority and 9
+        as the highest. In addition, clients should consider priorities 0-4 as
+        gradations of normal priority and priorities 5-9 as gradations of expedited
+        priority.
+
+        JMS does not require that a provider strictly implement priority ordering
+        of messages; however, it should do its best to deliver expedited messages
+        ahead of normal messages.
+        """
+        return self.get("priority")
+
+
+class ActiveMQEvent(DictWrapper):
+    """Represents an Active MQ event sent to Lambda
+
+    Documentation:
+    --------------
+    - https://docs.aws.amazon.com/lambda/latest/dg/with-mq.html
+    - https://aws.amazon.com/blogs/compute/using-amazon-mq-as-an-event-source-for-aws-lambda/
+    """
+
+    @property
+    def event_source(self) -> str:
+        return self["eventSource"]
+
+    @property
+    def event_source_arn(self) -> str:
+        """The Amazon Resource Name (ARN) of the event source"""
+        return self["eventSourceArn"]
+
+    @property
+    def messages(self) -> Iterator[ActiveMQMessage]:
+        for record in self["messages"]:
+            yield ActiveMQMessage(record)
+
+    @property
+    def message(self) -> ActiveMQMessage:
+        return next(self.messages)

aws_lambda_powertools/utilities/data_classes/rabbit_mq_event.py

@@ -0,0 +1,121 @@
+import base64
+import json
+from typing import Any, Dict, List
+
+from aws_lambda_powertools.utilities.data_classes.common import DictWrapper
+
+
+class BasicProperties(DictWrapper):
+    @property
+    def content_type(self) -> str:
+        return self["contentType"]
+
+    @property
+    def content_encoding(self) -> str:
+        return self["contentEncoding"]
+
+    @property
+    def headers(self) -> Dict[str, Any]:
+        return self["headers"]
+
+    @property
+    def delivery_mode(self) -> int:
+        return self["deliveryMode"]
+
+    @property
+    def priority(self) -> int:
+        return self["priority"]
+
+    @property
+    def correlation_id(self) -> str:
+        return self["correlationId"]
+
+    @property
+    def reply_to(self) -> str:
+        return self["replyTo"]
+
+    @property
+    def expiration(self) -> str:
+        return self["expiration"]
+
+    @property
+    def message_id(self) -> str:
+        return self["messageId"]
+
+    @property
+    def timestamp(self) -> str:
+        return self["timestamp"]
+
+    @property
+    def get_type(self) -> str:
+        return self["type"]
+
+    @property
+    def user_id(self) -> str:
+        return self["userId"]
+
+    @property
+    def app_id(self) -> str:
+        return self["appId"]
+
+    @property
+    def cluster_id(self) -> str:
+        return self["clusterId"]
+
+    @property
+    def body_size(self) -> int:
+        return self["bodySize"]
+
+
+class RabbitMessage(DictWrapper):
+    @property
+    def basic_properties(self) -> BasicProperties:
+        return BasicProperties(self["basicProperties"])
+
+    @property
+    def redelivered(self) -> bool:
+        return self["redelivered"]
+
+    @property
+    def data(self) -> str:
+        return self["data"]
+
+    @property
+    def decoded_data(self) -> str:
+        """Decodes the data as a str"""
+        return base64.b64decode(self.data.encode()).decode()
+
+    @property
+    def json_data(self) -> Any:
+        """Parses the data as json"""
+        return json.loads(self.decoded_data)
+
+
+class RabbitMQEvent(DictWrapper):
+    """Represents a Rabbit MQ event sent to Lambda
+
+    Documentation:
+    --------------
+    - https://docs.aws.amazon.com/lambda/latest/dg/with-mq.html
+    - https://aws.amazon.com/blogs/compute/using-amazon-mq-for-rabbitmq-as-an-event-source-for-lambda/
+    """
+
+    def __init__(self, data: Dict[str, Any]):
+        super().__init__(data)
+        self._rmq_messages_by_queue = {
+            key: [RabbitMessage(message) for message in messages]
+            for key, messages in self["rmqMessagesByQueue"].items()
+        }
+
+    @property
+    def event_source(self) -> str:
+        return self["eventSource"]
+
+    @property
+    def event_source_arn(self) -> str:
+        """The Amazon Resource Name (ARN) of the event source"""
+        return self["eventSourceArn"]
+
+    @property
+    def rmq_messages_by_queue(self) -> Dict[str, List[RabbitMessage]]:
+        return self._rmq_messages_by_queue

docs/index.md

@@ -43,8 +43,8 @@ Include Lambda Powertools in your function using the [AWS Lambda Console](https:
     MyLambdaFunction:
         Type: AWS::Serverless::Function
         Properties:
-        Layers:
-            - !Sub arn:aws:lambda:${AWS::Region}:017000801446:layer:AWSLambdaPowertoolsPython:3
+            Layers:
+                - !Sub arn:aws:lambda:${AWS::Region}:017000801446:layer:AWSLambdaPowertoolsPython:3
     ```
 
 === "Serverless framework"
@@ -196,16 +196,16 @@ If using SAM, you can include this SAR App as part of your shared Layers stack,
     AwsLambdaPowertoolsPythonLayer:
         Type: AWS::Serverless::Application
         Properties:
-        Location:
-            ApplicationId: arn:aws:serverlessrepo:eu-west-1:057560766410:applications/aws-lambda-powertools-python-layer
-            SemanticVersion: 1.21.1 # change to latest semantic version available in SAR
+            Location:
+                ApplicationId: arn:aws:serverlessrepo:eu-west-1:057560766410:applications/aws-lambda-powertools-python-layer
+                SemanticVersion: 1.21.1 # change to latest semantic version available in SAR
 
     MyLambdaFunction:
         Type: AWS::Serverless::Function
         Properties:
-        Layers:
-            # fetch Layer ARN from SAR App stack output
-            - !GetAtt AwsLambdaPowertoolsPythonLayer.Outputs.LayerVersionArn
+            Layers:
+                # fetch Layer ARN from SAR App stack output
+                - !GetAtt AwsLambdaPowertoolsPythonLayer.Outputs.LayerVersionArn
     ```
 
 === "Serverless framework"
@@ -223,10 +223,10 @@ If using SAM, you can include this SAR App as part of your shared Layers stack,
         AwsLambdaPowertoolsPythonLayer:
             Type: AWS::Serverless::Application
             Properties:
-            Location:
-                ApplicationId: arn:aws:serverlessrepo:eu-west-1:057560766410:applications/aws-lambda-powertools-python-layer
-                # Find latest from github.com/awslabs/aws-lambda-powertools-python/releases
-                SemanticVersion: 1.21.1
+                Location:
+                    ApplicationId: arn:aws:serverlessrepo:eu-west-1:057560766410:applications/aws-lambda-powertools-python-layer
+                    # Find latest from github.com/awslabs/aws-lambda-powertools-python/releases
+                    SemanticVersion: 1.21.1
     ```
 
 === "CDK"

docs/utilities/data_classes.md

@@ -58,6 +58,7 @@ Same example as above, but using the `event_source` decorator
 
 Event Source | Data_class
 ------------------------------------------------- | ---------------------------------------------------------------------------------
+[Active MQ](#active-mq) | `ActiveMQEvent`
 [API Gateway Authorizer](#api-gateway-authorizer) | `APIGatewayAuthorizerRequestEvent`
 [API Gateway Authorizer V2](#api-gateway-authorizer-v2) | `APIGatewayAuthorizerEventV2`
 [API Gateway Proxy](#api-gateway-proxy) | `APIGatewayProxyEvent`
@@ -72,6 +73,7 @@ Event Source | Data_class
 [DynamoDB streams](#dynamodb-streams) | `DynamoDBStreamEvent`, `DynamoDBRecordEventName`
 [EventBridge](#eventbridge) | `EventBridgeEvent`
 [Kinesis Data Stream](#kinesis-streams) | `KinesisStreamEvent`
+[Rabbit MQ](#rabbit-mq) | `RabbitMQEvent`
 [S3](#s3) | `S3Event`
 [S3 Object Lambda](#s3-object-lambda) | `S3ObjectLambdaEvent`
 [SES](#ses) | `SESEvent`
@@ -82,6 +84,31 @@ Event Source | Data_class
     The examples provided below are far from exhaustive - the data classes themselves are designed to provide a form of
     documentation inherently (via autocompletion, types and docstrings).
 
+### Active MQ
+
+It is used for [Active MQ payloads](https://docs.aws.amazon.com/lambda/latest/dg/with-mq.html){target="_blank"}, also see
+the [AWS blog post](https://aws.amazon.com/blogs/compute/using-amazon-mq-as-an-event-source-for-aws-lambda/){target="_blank"}
+for more details.
+
+=== "app.py"
+
+    ```python hl_lines="4-5 9-10"
+    from typing import Dict
+
+    from aws_lambda_powertools import Logger
+    from aws_lambda_powertools.utilities.data_classes import event_source
+    from aws_lambda_powertools.utilities.data_classes.active_mq_event import ActiveMQEvent
+
+    logger = Logger()
+
+    @event_source(data_class=ActiveMQEvent)
+    def lambda_handler(event: ActiveMQEvent, context):
+        for message in event.messages:
+            logger.debug(f"MessageID: {message.message_id}")
+            data: Dict = message.json_data
+            logger.debug("Process json in base64 encoded data str", data)
+    ```
+
 ### API Gateway Authorizer
 
 > New in 1.20.0
@@ -810,6 +837,33 @@ or plain text, depending on the original payload.
         do_something_with(data)
     ```
 
+### Rabbit MQ
+
+It is used for [Rabbit MQ payloads](https://docs.aws.amazon.com/lambda/latest/dg/with-mq.html){target="_blank"}, also see
+the [blog post](https://aws.amazon.com/blogs/compute/using-amazon-mq-for-rabbitmq-as-an-event-source-for-lambda/){target="_blank"}
+for more details.
+
+=== "app.py"
+
+    ```python hl_lines="4-5 9-10"
+    from typing import Dict
+
+    from aws_lambda_powertools import Logger
+    from aws_lambda_powertools.utilities.data_classes import event_source
+    from aws_lambda_powertools.utilities.data_classes.rabbit_mq_event import RabbitMQEvent
+
+    logger = Logger()
+
+    @event_source(data_class=RabbitMQEvent)
+    def lambda_handler(event: RabbitMQEvent, context):
+        for queue_name, messages in event.rmq_messages_by_queue.items():
+            logger.debug(f"Messages for queue: {queue_name}")
+            for message in messages:
+                logger.debug(f"MessageID: {message.basic_properties.message_id}")
+                data: Dict = message.json_data
+                logger.debug("Process json in base64 encoded data str", data)
+    ```
+
 ### S3
 
 === "app.py"

docs/utilities/middleware_factory.md

@@ -47,9 +47,8 @@ You can also have your own keyword arguments after the mandatory arguments.
         # Obfuscate email before calling Lambda handler
         if fields:
             for field in fields:
-                field = event.get(field, "")
                 if field in event:
-                    event[field] = obfuscate(field)
+                    event[field] = obfuscate(event[field])
 
         return handler(event, context)
 

docs/utilities/parser.md

@@ -57,8 +57,9 @@ Use the decorator for fail fast scenarios where you want your Lambda function to
 === "event_parser_decorator.py"
 
     ```python hl_lines="18"
-    from aws_lambda_powertools.utilities.parser import event_parser, BaseModel, ValidationError
+    from aws_lambda_powertools.utilities.parser import event_parser, BaseModel
     from aws_lambda_powertools.utilities.typing import LambdaContext
+    from typing import List, Optional
 
     import json
 
@@ -80,7 +81,7 @@ Use the decorator for fail fast scenarios where you want your Lambda function to
         print(event.description)
         print(event.items)
 
-        order_items = [items for item in event.items]
+        order_items = [item for item in event.items]
         ...
 
     payload = {
@@ -107,6 +108,7 @@ Use this standalone function when you want more control over the data validation
 
     ```python hl_lines="21 30"
     from aws_lambda_powertools.utilities.parser import parse, BaseModel, ValidationError
+    from typing import List, Optional
 
     class OrderItem(BaseModel):
         id: int

poetry.lock

@@ -38,19 +38,19 @@ flake8-builtins = "^1.5.3"
 flake8-comprehensions = "^3.7.0"
 flake8-debugger = "^4.0.0"
 flake8-fixme = "^1.1.1"
-flake8-isort = "^4.0.0"
+flake8-isort = "^4.1.1"
 flake8-variables-names = "^0.0.4"
 isort = "^5.9.3"
 pytest-cov = "^3.0.0"
 pytest-mock = "^3.5.1"
 pdoc3 = "^0.10.0"
-pytest-asyncio = "^0.15.1"
+pytest-asyncio = "^0.16.0"
 bandit = "^1.7.0"
 radon = "^5.1.0"
 xenon = "^0.8.0"
-flake8-eradicate = "^1.1.0"
+flake8-eradicate = "^1.2.0"
 flake8-bugbear = "^21.9.2"
-mkdocs-material = "^7.3.3"
+mkdocs-material = "^7.3.5"
 mkdocs-git-revision-date-plugin = "^0.3.1"
 mike = "^0.6.0"
 mypy = "^0.910"

pyproject.toml

@@ -0,0 +1,45 @@
+{
+  "eventSource": "aws:amq",
+  "eventSourceArn": "arn:aws:mq:us-west-2:112556298976:broker:test:b-9bcfa592-423a-4942-879d-eb284b418fc8",
+  "messages": [
+    {
+      "messageID": "ID:b-9bcfa592-423a-4942-879d-eb284b418fc8-1.mq.us-west-2.amazonaws.com-37557-1234520418293-4:1:1:1:1",
+      "messageType": "jms/text-message",
+      "data": "QUJDOkFBQUE=",
+      "connectionId": "myJMSCoID",
+      "redelivered": false,
+      "destination": {
+        "physicalname": "testQueue"
+      },
+      "timestamp": 1598827811958,
+      "brokerInTime": 1598827811958,
+      "brokerOutTime": 1598827811959
+    },
+    {
+      "messageID": "ID:b-9bcfa592-423a-4942-879d-eb284b418fc8-1.mq.us-west-2.amazonaws.com-37557-1234520418293-4:1:1:1:1",
+      "messageType": "jms/text-message",
+      "data": "eyJ0aW1lb3V0IjowLCJkYXRhIjoiQ1pybWYwR3c4T3Y0YnFMUXhENEUifQ==",
+      "connectionId": "myJMSCoID2",
+      "redelivered": false,
+      "destination": {
+        "physicalname": "testQueue"
+      },
+      "timestamp": 1598827811958,
+      "brokerInTime": 1598827811958,
+      "brokerOutTime": 1598827811959
+    },
+    {
+      "messageID": "ID:b-9bcfa592-423a-4942-879d-eb284b418fc8-1.mq.us-west-2.amazonaws.com-37557-1234520418293-4:1:1:1:1",
+      "messageType": "jms/bytes-message",
+      "data": "3DTOOW7crj51prgVLQaGQ82S48k=",
+      "connectionId": "myJMSCoID1",
+      "persistent": false,
+      "destination": {
+        "physicalname": "testQueue"
+      },
+      "timestamp": 1598827811958,
+      "brokerInTime": 1598827811958,
+      "brokerOutTime": 1598827811959
+    }
+  ]
+}

tests/events/activeMQEvent.json

@@ -0,0 +1,51 @@
+{
+  "eventSource": "aws:rmq",
+  "eventSourceArn": "arn:aws:mq:us-west-2:112556298976:broker:pizzaBroker:b-9bcfa592-423a-4942-879d-eb284b418fc8",
+  "rmqMessagesByQueue": {
+    "pizzaQueue::/": [
+      {
+        "basicProperties": {
+          "contentType": "text/plain",
+          "contentEncoding": null,
+          "headers": {
+            "header1": {
+              "bytes": [
+                118,
+                97,
+                108,
+                117,
+                101,
+                49
+              ]
+            },
+            "header2": {
+              "bytes": [
+                118,
+                97,
+                108,
+                117,
+                101,
+                50
+              ]
+            },
+            "numberInHeader": 10
+          },
+          "deliveryMode": 1,
+          "priority": 34,
+          "correlationId": null,
+          "replyTo": null,
+          "expiration": "60000",
+          "messageId": null,
+          "timestamp": "Jan 1, 1970, 12:33:41 AM",
+          "type": null,
+          "userId": "AIDACKCEVSQ6C2EXAMPLE",
+          "appId": null,
+          "clusterId": null,
+          "bodySize": 80
+        },
+        "redelivered": false,
+        "data": "eyJ0aW1lb3V0IjowLCJkYXRhIjoiQ1pybWYwR3c4T3Y0YnFMUXhENEUifQ=="
+      }
+    ]
+  }
+}

tests/events/rabbitMQEvent.json

@@ -0,0 +1,69 @@
+from typing import Dict
+
+from aws_lambda_powertools.utilities.data_classes.active_mq_event import ActiveMQEvent, ActiveMQMessage
+from aws_lambda_powertools.utilities.data_classes.rabbit_mq_event import BasicProperties, RabbitMessage, RabbitMQEvent
+from tests.functional.utils import load_event
+
+
+def test_active_mq_event():
+    event = ActiveMQEvent(load_event("activeMQEvent.json"))
+
+    assert event.event_source == "aws:amq"
+    assert event.event_source_arn is not None
+    assert len(list(event.messages)) == 3
+
+    message = event.message
+    assert isinstance(message, ActiveMQMessage)
+    assert message.message_id is not None
+    assert message.message_type is not None
+    assert message.data is not None
+    assert message.decoded_data is not None
+    assert message.connection_id is not None
+    assert message.redelivered is False
+    assert message.timestamp is not None
+    assert message.broker_in_time is not None
+    assert message.broker_out_time is not None
+    assert message.destination_physicalname is not None
+    assert message.delivery_mode is None
+    assert message.correlation_id is None
+    assert message.reply_to is None
+    assert message.get_type is None
+    assert message.expiration is None
+    assert message.priority is None
+
+    messages = list(event.messages)
+    message = messages[1]
+    assert message.json_data["timeout"] == 0
+
+
+def test_rabbit_mq_event():
+    event = RabbitMQEvent(load_event("rabbitMQEvent.json"))
+
+    assert event.event_source == "aws:rmq"
+    assert event.event_source_arn is not None
+
+    message = event.rmq_messages_by_queue["pizzaQueue::/"][0]
+    assert message.redelivered is False
+    assert message.data is not None
+    assert message.decoded_data is not None
+    assert message.json_data["timeout"] == 0
+
+    assert isinstance(message, RabbitMessage)
+    properties = message.basic_properties
+    assert isinstance(properties, BasicProperties)
+    assert properties.content_type == "text/plain"
+    assert properties.content_encoding is None
+    assert isinstance(properties.headers, Dict)
+    assert properties.headers["header1"] is not None
+    assert properties.delivery_mode == 1
+    assert properties.priority == 34
+    assert properties.correlation_id is None
+    assert properties.reply_to is None
+    assert properties.expiration == "60000"
+    assert properties.message_id is None
+    assert properties.timestamp is not None
+    assert properties.get_type is None
+    assert properties.user_id is not None
+    assert properties.app_id is None
+    assert properties.cluster_id is None
+    assert properties.body_size == 80

tests/functional/data_classes/test_amazon_mq.py

@@ -4,6 +4,7 @@
 import pytest
 
 from aws_lambda_powertools.event_handler import AppSyncResolver
+from aws_lambda_powertools.event_handler.appsync import Router
 from aws_lambda_powertools.utilities.data_classes import AppSyncResolverEvent
 from aws_lambda_powertools.utilities.typing import LambdaContext
 from tests.functional.utils import load_event
@@ -161,3 +162,29 @@ def create_something(id: str):  # noqa AA03 VNE003
     assert result == "my identifier"
 
     assert app.current_event.country_viewer == "US"
+
+
+def test_resolver_include_resolver():
+    # GIVEN
+    app = AppSyncResolver()
+    router = Router()
+
+    @router.resolver(type_name="Query", field_name="listLocations")
+    def get_locations(name: str):
+        return "get_locations#" + name
+
+    @app.resolver(field_name="listLocations2")
+    def get_locations2(name: str):
+        return "get_locations2#" + name
+
+    app.include_router(router)
+
+    # WHEN
+    mock_event1 = {"typeName": "Query", "fieldName": "listLocations", "arguments": {"name": "value"}}
+    mock_event2 = {"typeName": "Query", "fieldName": "listLocations2", "arguments": {"name": "value"}}
+    result1 = app.resolve(mock_event1, LambdaContext())
+    result2 = app.resolve(mock_event2, LambdaContext())
+
+    # THEN
+    assert result1 == "get_locations#value"
+    assert result2 == "get_locations2#value"