issue #23 - fixing issues from integration test, part 3

tests/adapter/test_backpressure_handler.py

@@ -86,13 +86,13 @@ class TestScaleRequestV1:
 
     def test_scale_request_v1_to_json_different_alert_type(self):
         """
-        Test the to_json method with a different ScalingRequestAlert type_string.
+        Test the to_json method with a different ScalingRequestAlert type.
         """
         service_id = "test-service"
         task_id = "test-task"
         max_availability = 10
         current_availability = 5
-        request_type = ScalingRequestAlert.OVERLOAD  # Change the alert type_string
+        request_type = ScalingRequestAlert.OVERLOAD  # Change the alert type
 
         scale_request = ScaleRequestV1(
             service_id,

tests/adapter/test_cleverthis_service_adapter.py

@@ -1,10 +1,13 @@
 import asyncio
 import unittest
+from enum import Enum
+from typing import Any, List, Optional
 from unittest.mock import AsyncMock, MagicMock, patch
 
 from aio_pika.abc import AbstractChannel, AbstractRobustConnection
 from aiohttp import ClientResponse
 from aiohttp.web_fileresponse import FileResponse
+from pydantic import BaseModel
 
 from amqp.adapter.cleverthis_service_adapter import (
     AMQMessage,
@@ -19,6 +22,26 @@ from amqp.model.model import DataResponse
 from amqp.router.router_base import AMQ_REPLY_TO_EXCHANGE
 
 
+class NestedModel(BaseModel):
+    id: int
+    name: str
+
+
+class ComplexModel(BaseModel):
+    nested: NestedModel
+    items: List[str]
+
+
+class TestEnum(Enum):
+    VALUE1 = "value1"
+    VALUE2 = "value2"
+
+
+class TestModel(BaseModel):
+    name: str
+    value: int
+
+
 class TestCleverThisServiceAdapter(unittest.IsolatedAsyncioTestCase):
 
     async def test_create_reply_exchange_and_queue_success(self):
@@ -89,6 +112,7 @@ class TestCleverThisServiceAdapter(unittest.IsolatedAsyncioTestCase):
             amq_configuration=self.mock_amq_config, routes=[], session=self.mock_session
         )
         self.adapter.service_host = "testhost"
+        self.adapter.authenticated_user_arg_name = "user"
 
     def test_init(self):
         self.assertEqual(self.adapter.service_host, "testhost")
@@ -98,7 +122,7 @@ class TestCleverThisServiceAdapter(unittest.IsolatedAsyncioTestCase):
     def test_get_content_type(self):
         test_cases = [
             ({"Content-Type": ["application/json"]}, "application/json"),
-            ({"content-type_string": ["text/xml"]}, "text/xml"),
+            ({"content-type": ["text/xml"]}, "text/xml"),
             ({"CONTENT-TYPE": ["text/plain; charset=utf-8"]}, "text/plain"),
             ({}, "application/json"),
             ({"Other-Header": ["value"]}, "application/json"),
@@ -282,6 +306,126 @@ class TestCleverThisServiceAdapter(unittest.IsolatedAsyncioTestCase):
         with self.assertRaises(NotImplementedError):
             await self.adapter.head(mock_message, None)
 
+    def test_basic_type_conversion(self):
+        async def test_method(x: int, y: float, z: bool, text: str):
+            pass
+
+        args = {"x": "123", "y": "45.67", "z": "true", "text": "hello"}
+
+        result = self.adapter._verify_and_instantiate_arguments(args, test_method)
+
+        self.assertEqual(result["x"], 123)
+        self.assertEqual(result["y"], 45.67)
+        self.assertEqual(result["z"], True)
+        self.assertEqual(result["text"], "hello")
+
+    def test_enum_conversion(self):
+        async def test_method(status: TestEnum):
+            pass
+
+        args = {"status": "value1"}
+        result = self.adapter._verify_and_instantiate_arguments(args, test_method)
+
+        self.assertEqual(result["status"], TestEnum.VALUE1)
+
+    def test_optional_parameter(self):
+        async def test_method(required: str, optional: Optional[str] = None):
+            pass
+
+        args = {"required": "test"}
+        result = self.adapter._verify_and_instantiate_arguments(args, test_method)
+
+        self.assertEqual(result["required"], "test")
+        self.assertIsNone(result["optional"])
+
+    def test_list_parameter(self):
+        async def test_method(items: List[str]):
+            pass
+
+        args = {"items": "item1,item2,item3"}
+        result = self.adapter._verify_and_instantiate_arguments(args, test_method)
+
+        self.assertEqual(result["items"], ["item1", "item2", "item3"])
+
+    def test_pydantic_model_parameter(self):
+        async def test_method(model: TestModel):
+            pass
+
+        args = {"model": '{"name": "test", "value": 42}'}
+        result = self.adapter._verify_and_instantiate_arguments(args, test_method)
+
+        self.assertIsInstance(result["model"], TestModel)
+        self.assertEqual(result["model"].name, "test")
+        self.assertEqual(result["model"].value, 42)
+
+    def test_authenticated_user_parameter(self):
+        async def test_method(user: Any):
+            pass
+
+        user_obj = MagicMock()
+        args = {"user": user_obj}
+        result = self.adapter._verify_and_instantiate_arguments(args, test_method)
+
+        self.assertEqual(result["user"], user_obj)
+
+    def test_missing_required_parameter(self):
+        async def test_method(required: str):
+            pass
+
+        args = {}
+        result = self.adapter._verify_and_instantiate_arguments(args, test_method)
+
+        self.assertNotIn("required", result)
+
+    def test_invalid_enum_value(self):
+        async def test_method(status: TestEnum):
+            pass
+
+        args = {"status": "invalid_value"}
+        result = self.adapter._verify_and_instantiate_arguments(args, test_method)
+
+        self.assertEqual(result["status"], "invalid_value")
+
+    def test_invalid_type_conversion(self):
+        async def test_method(x: int):
+            pass
+
+        args = {"x": "not_a_number"}
+        result = {}
+        try:
+            result = self.adapter._verify_and_instantiate_arguments(args, test_method)
+        except Exception as e:
+            self.assertTrue(isinstance(e, TypeError))
+
+        self.assertEqual(len(result), 0)
+
+    def test_complex_nested_model(self):
+
+        async def test_method(model: ComplexModel):
+            pass
+
+        args = {"model": {"nested": {"id": 1, "name": "test"}, "items": ["item1", "item2"]}}
+        result = self.adapter._verify_and_instantiate_arguments(args, test_method)
+
+        self.assertIsInstance(result["model"], ComplexModel)
+        self.assertEqual(result["model"].nested.id, 1)
+        self.assertEqual(result["model"].nested.name, "test")
+        self.assertEqual(result["model"].items, ["item1", "item2"])
+
+    def test_default_factory_parameter(self):
+        class DefaultFactory:
+            @staticmethod
+            def default_factory():
+                return "default_value"
+
+        async def test_method(param: str = DefaultFactory()):
+            pass
+
+        args = {}
+        result = self.adapter._verify_and_instantiate_arguments(args, test_method)
+
+        self.assertEqual(result["param"], "default_value")
+
 
 if __name__ == "__main__":
     unittest.main()

tests/adapter/test_service_message_factory.py

@@ -15,11 +15,11 @@ class ServiceMessageTest(TestCase):
         _f: ServiceMessageFactory = ServiceMessageFactory("bumble-bee")
         message: ServiceMessage = _f.of(ServiceMessageType.ROUTING_DATA, "Duck", "Donald")
         message_str = _f.to_string(message)
-        self.assertTrue("|type_string=01|" in message_str)
+        self.assertTrue("|type=01|" in message_str)
         self.assertTrue("|body=Duck" in message_str)
         message: ServiceMessage = _f.of(ServiceMessageType.ROUTING_DATA_REPLACE, "Duck", "Donald")
         message_str = _f.to_string(message)
-        self.assertTrue("|type_string=03|" in message_str)
+        self.assertTrue("|type=03|" in message_str)
         self.assertTrue("|body=Duck" in message_str)
         self.assertTrue("|replyTo=bumble-bee" in message_str)
         nullMsg = _f.to_string(None)

tests/adapter/test_type_descriptor.py

@@ -8,28 +8,28 @@ class TestTypeDescriptor(unittest.TestCase):
         type_str = (
             "typing.Optional[typing.Annotated[core.base.providers.ingestion.IngestionConfig, Json]]"
         )
-        td = TypeDescriptor(type_str)
+        td = TypeDescriptor(type_str, {})
 
         self.assertEqual(td.type, "core.base.providers.ingestion.IngestionConfig")
         self.assertTrue(td.is_json)
 
     def test_annotated_without_json(self):
         type_str = "typing.Optional[typing.Annotated[str, SomethingElse]]"
-        td = TypeDescriptor(type_str)
+        td = TypeDescriptor(type_str, {})
 
         self.assertEqual(td.type, "str")
         self.assertFalse(td.is_json)
 
     def test_annotated_multiple_args(self):
         type_str = "typing.Optional[typing.Annotated[list[int], Json, more_args]]"
-        td = TypeDescriptor(type_str)
+        td = TypeDescriptor(type_str, {})
 
         self.assertEqual(td.type, "list[int]")
         self.assertTrue(td.is_json)
 
     def test_simple_optional(self):
         type_str = "typing.Optional[uuid.UUID]"
-        td = TypeDescriptor(type_str)
+        td = TypeDescriptor(type_str, {})
 
         self.assertEqual(td.type, "uuid.UUID")
         self.assertFalse(td.is_json)
@@ -43,29 +43,28 @@ class TestTypeDescriptor(unittest.TestCase):
 
         for type_str, expected_type, expected_json in test_cases:
             with self.subTest(type_str=type_str):
-                td = TypeDescriptor(type_str)
+                td = TypeDescriptor(type_str, {})
                 self.assertEqual(td.type, expected_type)
                 self.assertEqual(td.is_json, expected_json)
 
     def test_invalid_input(self):
         test_cases = [
-            "not.a.valid.type_string.string",
             "typing.Optional[missing_bracket",
             "typing.Optional[]",
-            "typing.Annotated[without.optional]",
+            "[without.optional]",
         ]
 
         for type_str in test_cases:
             with self.subTest(type_str=type_str):
-                td = TypeDescriptor(type_str)
+                td = TypeDescriptor(type_str, {})
                 self.assertEqual(td.type, "")
                 self.assertFalse(td.is_json)
 
     def test_repr(self):
         type_str = "typing.Optional[typing.Annotated[str, Json]]"
-        td = TypeDescriptor(type_str)
+        td = TypeDescriptor(type_str, {})
 
-        self.assertEqual(repr(td), "TypeDescriptor(type_string='str', is_json=True)")
+        self.assertEqual(repr(td), "TypeDescriptor(type='str', is_json=True)")
 
 
 if __name__ == "__main__":

tests/model/test_model.py

@@ -49,7 +49,7 @@ class TestCleverMicroMessage(unittest.TestCase):
     def test_content_type(self):
         self.assertEqual(self.message.content_type(), "application/json")
 
-        # Test default content type_string
+        # Test default content type
         message_no_content_type = CleverMicroMessage(
             magic="A",
             id=self.test_id,