From e09fd70900b7f03f420ba4c88361071072b8d6cb Mon Sep 17 00:00:00 2001
From: misdirection <misdirection@live.de>
Date: Wed, 18 Sep 2024 22:31:17 +0200
Subject: [PATCH] added async support

---
 medyator/medyator.py   | 13 ++++++++-----
 medyator/sender.py     |  9 ++++++---
 tests/test_medyator.py | 30 +++++++++++++++++++-----------
 3 files changed, 33 insertions(+), 19 deletions(-)

diff --git a/medyator/medyator.py b/medyator/medyator.py
index 6d4a011..88cbd5a 100644
--- a/medyator/medyator.py
+++ b/medyator/medyator.py
@@ -1,3 +1,4 @@
+# medyator.py
 from abc import ABC
 from typing import Callable, Dict, Type, TypeVar, Union, cast, overload
 
@@ -36,12 +37,14 @@ def __init__(self, service_provider: ServiceProvider) -> None:
         self.__handlers = HandlerContainer()
 
     @overload
-    def send(self, request: Command) -> None: ...
+    async def send(self, request: Command) -> None: ...
 
     @overload
-    def send(self, request: Query[TResponse]) -> TResponse: ...
+    async def send(self, request: Query[TResponse]) -> TResponse: ...
 
-    def send(self, request: Union[Command, Query[TResponse]]) -> Union[None, TResponse]:
+    async def send(
+        self, request: Union[Command, Query[TResponse]]
+    ) -> Union[None, TResponse]:
         try:
             if isinstance(request, Command):
                 handler = cast(
@@ -51,7 +54,7 @@ def send(self, request: Union[Command, Query[TResponse]]) -> Union[None, TRespon
                         lambda: CommandHandlerWrapperImpl[type(request)](),
                     ),
                 )
-                handler(request, self.__service_provider)
+                await handler(request, self.__service_provider)
                 return None
             elif isinstance(request, Query):
                 handler = cast(
@@ -61,7 +64,7 @@ def send(self, request: Union[Command, Query[TResponse]]) -> Union[None, TRespon
                         lambda: QueryHandlerWrapperImpl[type(request), TResponse](),
                     ),
                 )
-                return handler(request, self.__service_provider)
+                return await handler(request, self.__service_provider)
             else:
                 raise TypeError("Unsupported request type")
         except KeyError:
diff --git a/medyator/sender.py b/medyator/sender.py
index 03ec0e7..5d12aef 100644
--- a/medyator/sender.py
+++ b/medyator/sender.py
@@ -9,12 +9,15 @@
 class Sender(ABC):
     @overload
     @abstractmethod
-    def send(self, request: Command) -> None: ...
+    async def send(self, request: Command) -> None: ...
 
     @overload
     @abstractmethod
-    def send(self, request: Query[TResponse]) -> TResponse: ...
+    async def send(self, request: Query[TResponse]) -> TResponse: ...
 
     @abstractmethod
-    def send(self, request: Union[Command, Query[TResponse]]) -> Union[None, TResponse]:
+    async def send(
+        self, request: Union[Command, Query[TResponse]]
+    ) -> Union[None, TResponse]:
         raise NotImplementedError
+
diff --git a/tests/test_medyator.py b/tests/test_medyator.py
index 2030302..92e86b6 100644
--- a/tests/test_medyator.py
+++ b/tests/test_medyator.py
@@ -18,7 +18,7 @@ def __init__(self, value: int) -> None:
             self.value = value
 
     class TestQueryHandler(QueryHandler[TestQuery, int]):
-        def __call__(self, request: TestQuery) -> int:
+        async def __call__(self, request: TestQuery) -> int:
             return request.value + 9000
 
     return TestQuery, TestQueryHandler()
@@ -35,40 +35,48 @@ class TestCommandHandler(CommandHandler[TestCommand]):
         def __init__(self) -> None:
             self.value = None
 
-        def __call__(self, request: TestCommand) -> None:
+        async def __call__(self, request: TestCommand) -> None:
             self.value = request.value
 
     return TestCommand, TestCommandHandler()
 
 
-def test_query_should_execute_query_handler_twice_and_return_same_value(test_query):
+@pytest.mark.asyncio
+async def test_query_should_execute_query_handler_twice_and_return_same_value(
+    test_query,
+):
     di.add_medyator()
     query, query_handler = test_query
     di[query] = query_handler
     medyator = di[Medyator]
 
-    # should get handler from serviceprovider (di container)
-    result = medyator.send(query(1))
+    # Should get handler from service provider (di container)
+    result = await medyator.send(query(1))
     assert result == 9001
 
-    # should get handler from medyator container
-    result = medyator.send(query(1))
+    # Should get handler from medyator container
+    result = await medyator.send(query(1))
     assert result == 9001
 
 
-def test_should_execute_command_handler_and_set_the_value(test_command):
+@pytest.mark.asyncio
+async def test_should_execute_command_handler_and_set_the_value(test_command):
     di.add_medyator()
     command, _ = test_command
     medyator = di[Medyator]
 
-    medyator.send(command("Hello, World!"))
+    await medyator.send(command("Hello, World!"))
     handler = di[command]
     assert handler.value == "Hello, World!"
 
 
-def test_should_raise_HandlerNotFound_error_when_query_handler_is_not_found(test_query):
+@pytest.mark.asyncio
+async def test_should_raise_HandlerNotFound_error_when_query_handler_is_not_found(
+    test_query,
+):
     di.add_medyator()
     medyator = di[Medyator]
     query, _ = test_query
     with pytest.raises(HandlerNotFound):
-        medyator.send(query(1))
+        await medyator.send(query(1))
+