feat: 100% test coverage

Author: andrewthetechie

pydantic_sqs/exceptions.py

@@ -14,7 +14,7 @@ class MessageNotInQueueError(PydanticSQSError):
     pass
 
 
-class InvaidMessageInQueueError(PydanticSQSError):
+class InvalidMessageInQueueError(PydanticSQSError):
     pass
 
 

pydantic_sqs/model.py

@@ -1,5 +1,6 @@
 """Module containing the model classes"""
 import json
+from typing import Any
 from typing import Dict
 from typing import List
 from typing import Optional
@@ -80,19 +81,21 @@ async def from_sqs(
         )
         return [result for result in results if isinstance(result, cls)]
 
-    async def to_sqs(self, wait_time_in_seconds: int = None) -> None:
+    def __send_kwargs(
+        self, queue_url: str, wait_time_in_seconds: int = None
+    ) -> Dict[str, Any]:
         """
-        Send this object to SQS.
-        Well set this object's message_id to the message id rom SQS
+        Create the send kwargs
 
         Args:
             wait_time_in_seconds (int, optional): The length of time, in seconds, for which to delay a specific message.
                 Valid values: 0 to 900. Maximum: 15 minutes. Messages with a positive DelaySeconds value become
                 available for processing after the delay period is finished. If you don't specify a value, the
                 default value for the queue applies. Defaults to None. Greater than 0, less than or equal to 900
-        """
-        queue = self.__get_queue()
 
+        Returns:
+            Dict[str, Any]: send kwargs
+        """
         send_kwargs = {}
         if wait_time_in_seconds is not None:
             if wait_time_in_seconds < 0:
@@ -101,13 +104,31 @@ async def to_sqs(self, wait_time_in_seconds: int = None) -> None:
                 wait_time_in_seconds = 900
             send_kwargs["DelaySeconds"] = wait_time_in_seconds
 
-        send_kwargs["QueueUrl"] = queue.queue_url
+        send_kwargs["QueueUrl"] = queue_url
         send_kwargs["MessageBody"] = json.dumps(
             {
                 "model": self.__class__.__qualname__.lower(),
                 "message": self.dict(exclude_unset=True),
             }
         )
+        return send_kwargs
+
+    async def to_sqs(self, wait_time_in_seconds: int = None) -> None:
+        """
+        Send this object to SQS.
+        Well set this object's message_id to the message id rom SQS
+
+        Args:
+            wait_time_in_seconds (int, optional): The length of time, in seconds, for which to delay a specific message.
+                Valid values: 0 to 900. Maximum: 15 minutes. Messages with a positive DelaySeconds value become
+                available for processing after the delay period is finished. If you don't specify a value, the
+                default value for the queue applies. Defaults to None. Greater than 0, less than or equal to 900
+        """
+        queue = self.__get_queue()
+
+        send_kwargs = self.__send_kwargs(
+            queue_url=queue.queue_url, wait_time_in_seconds=wait_time_in_seconds
+        )
         async with queue.session.create_client("sqs", **queue.client_kwargs) as client:
             response = await client.send_message(**send_kwargs)
 

pydantic_sqs/queue.py

@@ -69,6 +69,7 @@ def __init__(
         """
         if session is None:
             session = get_session()
+
         super().__init__(
             queue_url=queue_url,
             aws_region=aws_region,
@@ -109,9 +110,9 @@ def client_kwargs(self) -> Dict[str, Any]:
 
     def __recv_kwargs(
         self,
-        max_messages: Optional[int],
-        visibility_timeout: Optional[int],
-        wait_time_seconds: Optional[int],
+        max_messages: Optional[int] = None,
+        visibility_timeout: Optional[int] = None,
+        wait_time_seconds: Optional[int] = None,
     ) -> Dict[str, Any]:
         """
         __recv_kwargs - Get kwargs for recieving from sqs
@@ -166,11 +167,11 @@ async def from_sqs(
             ignore_empty (bool, optional): Whether or not to ignore an empty queue. Defaults to False. If True,
                 an empty queue will return an empty list and not raise a MsgNotFoundError
             ignore_unknown (bool, optional): Whether or not to ignore unknown messages. Defaults to False.
-                If true, unknown messages will not raise an InvaidMessageInQueueError and will simply return to the
+                If true, unknown messages will not raise an InvalidMessageInQueueError and will simply return to the
                 queue after their visibility timeout
         Raises:
             exceptions.MsgNotFoundError: If no messages are found in the queue
-            exceptions.InvaidMessageInQueueError: If an unknown message is found in the queue.
+            exceptions.InvalidMessageInQueueError: If an unknown message is found in the queue.
 
         Returns:
             list[SQSModel]: A list of SQSModels from the queue
@@ -184,33 +185,34 @@ async def from_sqs(
         to_return = []
 
         try:
-            messages = await self.__get_messages(recv_kwargs)
-        except exceptions.MsgNotFoundError:
+            messages = await self._get_messages(recv_kwargs)
+        except exceptions.MsgNotFoundError as exc:
             if ignore_empty:
                 messages = []
             else:
-                raise
-        except exceptions.InvaidMessageInQueueError:
-            if ignore_unknown:
-                messages = []
-            else:
-                raise
+                raise exc
+
         for msg in messages:
             try:
                 this_object = json.loads(msg["Body"])
+                to_return.append(
+                    self.__message_to_object(
+                        message=this_object,
+                        message_id=msg["MessageId"],
+                        receipt_handle=msg["ReceiptHandle"],
+                        attributes=msg.get("Attributes", None),
+                    )
+                )
             except json.JSONDecodeError as exc:
+                if ignore_unknown:
+                    continue
                 raise exceptions.InvalidMessageInQueueError(
                     f"Message {msg['MessageId']} is not valid JSON"
                 ) from exc
-
-            to_return.append(
-                self.__message_to_object(
-                    message=this_object,
-                    message_id=msg["MessageId"],
-                    receipt_handle=msg["ReceiptHandle"],
-                    attributes=msg.get("Attributes", None),
-                )
-            )
+            except exceptions.InvalidMessageInQueueError as exc:
+                if ignore_unknown:
+                    continue
+                raise exc
 
         return to_return
 
@@ -228,15 +230,15 @@ def __message_to_object(
             message (dict[str, Any]): _description_
 
         Raises:
-            exceptions.InvaidMessageInQueueError: _description_
+            exceptions.InvalidMessageInQueueError: _description_
 
         Returns:
             SQSModel: _description_
         """
         try:
             model = self.models[message["model"]]
         except KeyError:
-            raise exceptions.InvaidMessageInQueueError(
+            raise exceptions.InvalidMessageInQueueError(
                 f"No model registered to queue {self.queue_url} for model "
                 + f"type {message['model']} from {message_id}"
             ) from None
@@ -249,11 +251,11 @@ def __message_to_object(
                 **message["message"],
             )
         except ValidationError as exc:
-            raise exceptions.InvaidMessageInQueueError(
+            raise exceptions.InvalidMessageInQueueError(
                 f"Invalid message {message_id} from queue {self.queue_url}"
             ) from exc
 
-    async def __get_messages(
+    async def _get_messages(
         self,
         recv_kwargs: Dict[str, Any],
     ) -> List[Dict[str, Any]]:
@@ -272,6 +274,8 @@ async def __get_messages(
         async with self.session.create_client("sqs", **self.client_kwargs) as client:
             response = await client.receive_message(**recv_kwargs)
 
-            if "Messages" not in response:
-                raise exceptions.MsgNotFoundError(f"{self.queue_url} is empty")
-        return response["Messages"]
+        messages = response.get("Messages", [response.get("Message", None)])
+        if messages[0] is None:
+            raise exceptions.MsgNotFoundError(f"{self.queue_url} is empty")
+
+        return messages

test/conftest.py

@@ -1,12 +1,9 @@
 import os
 import random
 import string
-import time
 
 import docker
-import pytest
 import pytest_asyncio
-from aiobotocore.session import AioSession
 from aiobotocore.session import get_session
 from pydantic_sqs import SQSQueue
 

test/test_pydantic_SQSModel.py

@@ -1,10 +1,6 @@
+import pytest
 from pydantic_sqs import exceptions
 from pydantic_sqs import SQSModel
-from pydantic_sqs import SQSQueue
-
-import pytest
-import pytest_asyncio
-from aiobotocore.session import get_session
 
 
 @pytest.mark.asyncio
@@ -166,3 +162,42 @@ class ThatModel(SQSModel):
 
     from_sqs = await queue.from_sqs(max_messages=5)
     assert len(from_sqs) == 2
+
+
+def test_send_kwargs(localstack_queue):
+    class ThisModel(SQSModel):
+        test: str
+
+    queue = localstack_queue[0]
+    queue.register_model(ThisModel)
+    this_model = ThisModel(test="test")
+
+    kw_args = this_model._SQSModel__send_kwargs(queue_url=queue.queue_url)
+
+    assert "DelaySeconds" not in kw_args
+    assert kw_args["QueueUrl"] == queue.queue_url
+    assert isinstance(kw_args["MessageBody"], str)
+
+
+def test_send_kwargs_wait_time(localstack_queue):
+    class ThisModel(SQSModel):
+        test: str
+
+    queue = localstack_queue[0]
+    queue.register_model(ThisModel)
+    this_model = ThisModel(test="test")
+
+    # less than 0 becomes 0
+    assert (
+        this_model._SQSModel__send_kwargs(
+            queue_url=queue.queue_url, wait_time_in_seconds=-1
+        )["DelaySeconds"]
+        == 0
+    )
+    # greater than 900 becomes 900
+    assert (
+        this_model._SQSModel__send_kwargs(
+            queue_url=queue.queue_url, wait_time_in_seconds=901
+        )["DelaySeconds"]
+        == 900
+    )