ISSUE #209

* Log exception on `Port` start errors.

Author: Sergio García Prado

packages/core/minos-microservice-aggregate/tests/utils.py

@@ -73,20 +73,20 @@ def setUp(self) -> None:
                 self.snapshot_repository,
             ],
         )
-        self.injector.wire()
+        self.injector.wire_injections()
 
     async def asyncSetUp(self):
         await super().asyncSetUp()
 
-        await self.injector.setup()
+        await self.injector.setup_injections()
 
     async def asyncTearDown(self):
-        await self.injector.destroy()
+        await self.injector.destroy_injections()
 
         await super().asyncTearDown()
 
     def tearDown(self) -> None:
-        self.injector.unwire()
+        self.injector.unwire_injections()
         super().tearDown()
 
 

packages/core/minos-microservice-common/minos/common/injections/injectors.py

@@ -77,24 +77,24 @@ def _fn(raw: Union[_InjectableSetupMixin, Type[_InjectableSetupMixin], str]) ->
 
         return injections
 
-    async def wire_and_setup(self, *args, **kwargs) -> None:
+    async def wire_and_setup_injections(self, *args, **kwargs) -> None:
         """Connect the configuration.
 
         :return: This method does not return anything.
         """
 
-        self.wire(*args, **kwargs)
-        await self.setup()
+        self.wire_injections(*args, **kwargs)
+        await self.setup_injections()
 
-    async def unwire_and_destroy(self) -> None:
+    async def unwire_and_destroy_injections(self) -> None:
         """Disconnect the configuration.
 
         :return: This method does not return anything.
         """
-        await self.destroy()
-        self.unwire()
+        await self.destroy_injections()
+        self.unwire_injections()
 
-    def wire(self, modules=None, *args, **kwargs) -> None:
+    def wire_injections(self, modules=None, *args, **kwargs) -> None:
         """Connect the configuration.
 
         :return: This method does not return anything.
@@ -109,17 +109,25 @@ def wire(self, modules=None, *args, **kwargs) -> None:
 
         self.container.wire(modules=modules, *args, **kwargs)
 
-    def unwire(self) -> None:
+    def unwire_injections(self) -> None:
         """Disconnect the configuration.
 
         :return: This method does not return anything.
         """
         self.container.unwire()
 
-    async def setup(self):
+    async def setup_injections(self) -> None:
+        """Set Up the injections.
+
+        :return: This method does not return anything.
+        """
         await gather(*(injection.setup() for injection in self.injections.values()))
 
-    async def destroy(self):
+    async def destroy_injections(self) -> None:
+        """Destroy the injections
+
+        :return: This method does not return anything.
+        """
         await gather(*(injection.destroy() for injection in self.injections.values()))
 
     @cached_property

packages/core/minos-microservice-common/minos/common/launchers.py

@@ -186,7 +186,7 @@ async def _setup(self) -> None:
 
         :return: This method does not return anything.
         """
-        await self.injector.wire_and_setup(
+        await self.injector.wire_and_setup_injections(
             modules=self._external_modules + self._internal_modules, packages=self._external_packages
         )
 
@@ -199,7 +199,7 @@ async def _destroy(self) -> None:
 
         :return: This method does not return anything.
         """
-        await self.injector.unwire_and_destroy()
+        await self.injector.unwire_and_destroy_injections()
 
     @cached_property
     def injector(self) -> DependencyInjector:

packages/core/minos-microservice-common/minos/common/ports.py

@@ -1,3 +1,4 @@
+import logging
 from abc import (
     ABC,
     abstractmethod,
@@ -7,21 +8,37 @@
     Service,
 )
 
+logger = logging.getLogger(__name__)
+
 
 class Port(Service, ABC):
     """Port base class."""
 
-    @abstractmethod
     async def start(self) -> None:
         """Start the port execution.
 
         :return: This method does not return anything.
         """
+        try:
+            return await self._start()
+        except Exception as exc:
+            logger.exception(f"Raised an exception on {self!r} start: {exc!r}")
 
     @abstractmethod
+    def _start(self):
+        raise NotImplementedError
+
     async def stop(self, err: Exception = None) -> None:
         """Stop the port execution.
 
         :param err: Optional exception that stopped the execution.
         :return: This method does not return anything.
         """
+        try:
+            return await self._stop(err)
+        except Exception as exc:
+            logger.exception(f"Raised an exception on {self!r} stop: {exc!r}")
+
+    @abstractmethod
+    async def _stop(self, err: Exception = None) -> None:
+        raise NotImplementedError

packages/core/minos-microservice-common/tests/test_common/test_database/test_abc.py

@@ -33,12 +33,12 @@ async def test_pool(self):
 
     async def test_pool_with_dependency_injections(self):
         injector = DependencyInjector(self.config, [PostgreSqlPool])
-        await injector.wire_and_setup(modules=[sys.modules[__name__]])
+        await injector.wire_and_setup_injections(modules=[sys.modules[__name__]])
 
         async with PostgreSqlMinosDatabase(**self.repository_db) as database:
             self.assertEqual(injector.postgresql_pool, database.pool)
 
-        await injector.unwire_and_destroy()
+        await injector.unwire_and_destroy_injections()
 
     async def test_submit_query(self):
         async with PostgreSqlMinosDatabase(**self.repository_db) as database:

packages/core/minos-microservice-common/tests/test_common/test_injections/test_decorators.py

@@ -89,10 +89,10 @@ def setUp(self) -> None:
         super().setUp()
         self.foo = _Foo(34)
         self.injector = DependencyInjector(None, [self.foo])
-        self.injector.wire()
+        self.injector.wire_injections()
 
     def tearDown(self) -> None:
-        self.injector.unwire()
+        self.injector.unwire_injections()
         super().tearDown()
 
     def test_decorator_sync(self):

packages/core/minos-microservice-common/tests/test_common/test_injections/test_injectors.py

@@ -66,13 +66,13 @@ async def test_wire_unwire(self):
 
         mock = MagicMock()
         injector.container.wire = mock
-        await injector.wire_and_setup()
+        await injector.wire_and_setup_injections()
         self.assertEqual(1, mock.call_count)
         self.assertEqual(call(modules=[decorators]), mock.call_args)
 
         mock = MagicMock()
         injector.container.unwire = mock
-        await injector.unwire_and_destroy()
+        await injector.unwire_and_destroy_injections()
         self.assertEqual(1, mock.call_count)
 
     async def test_wire_unwire_with_modules(self):
@@ -84,13 +84,13 @@ async def test_wire_unwire_with_modules(self):
 
         mock = MagicMock()
         injector.container.wire = mock
-        await injector.wire_and_setup(modules=[sys.modules[__name__]])
+        await injector.wire_and_setup_injections(modules=[sys.modules[__name__]])
         self.assertEqual(1, mock.call_count)
         self.assertEqual(call(modules=[sys.modules[__name__], decorators]), mock.call_args)
 
         mock = MagicMock()
         injector.container.unwire = mock
-        await injector.unwire_and_destroy()
+        await injector.unwire_and_destroy_injections()
         self.assertEqual(1, mock.call_count)
 
 

packages/core/minos-microservice-common/tests/test_common/test_launchers.py

@@ -30,10 +30,10 @@ def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.kwargs = kwargs
 
-    async def start(self) -> None:
+    async def _start(self) -> None:
         """For testing purposes."""
 
-    async def stop(self, err: Exception = None) -> None:
+    async def _stop(self, err: Exception = None) -> None:
         """For testing purposes."""
 
 
@@ -99,7 +99,7 @@ async def test_loop(self):
 
     async def test_setup(self):
         mock = AsyncMock()
-        self.launcher.injector.wire_and_setup = mock
+        self.launcher.injector.wire_and_setup_injections = mock
         await self.launcher.setup()
 
         self.assertEqual(1, mock.call_count)
@@ -120,11 +120,11 @@ async def test_setup(self):
         await self.launcher.destroy()
 
     async def test_destroy(self):
-        self.launcher.injector.wire_and_setup = AsyncMock()
+        self.launcher.injector.wire_and_setup_injections = AsyncMock()
         await self.launcher.setup()
 
         mock = AsyncMock()
-        self.launcher.injector.unwire_and_destroy = mock
+        self.launcher.injector.unwire_and_destroy_injections = mock
         await self.launcher.destroy()
 
         self.assertEqual(1, mock.call_count)

packages/core/minos-microservice-common/tests/test_common/test_ports.py

@@ -1,4 +1,8 @@
 import unittest
+from unittest.mock import (
+    AsyncMock,
+    call,
+)
 
 from aiomisc import (
     Service,
@@ -9,13 +13,63 @@
 )
 
 
-class TestPort(unittest.TestCase):
+class _Port(Port):
+    """For testing purposes."""
+
+    def _start(self):
+        """For testing purposes."""
+
+    async def _stop(self, err: Exception = None) -> None:
+        """For testing purposes."""
+
+
+class TestPort(unittest.IsolatedAsyncioTestCase):
     def test_is_subclass(self):
         self.assertTrue(issubclass(Port, Service))
 
     def test_abstract(self):
         # noinspection PyUnresolvedReferences
-        self.assertEqual({"start", "stop"}, Port.__abstractmethods__)
+        self.assertEqual({"_start", "_stop"}, Port.__abstractmethods__)
+
+    async def test_start(self):
+        port = _Port()
+
+        mock = AsyncMock()
+        port._start = mock
+
+        await port.start()
+
+        self.assertEqual([call()], mock.call_args_list)
+
+    async def test_start_raises(self):
+        port = _Port()
+
+        mock = AsyncMock(side_effect=ValueError)
+        port._start = mock
+
+        await port.start()
+
+        self.assertEqual([call()], mock.call_args_list)
+
+    async def test_stop(self):
+        port = _Port()
+
+        mock = AsyncMock()
+        port._stop = mock
+
+        await port.stop()
+
+        self.assertEqual([call(None)], mock.call_args_list)
+
+    async def test_stop_raises(self):
+        port = _Port()
+
+        mock = AsyncMock(side_effect=ValueError)
+        port._stop = mock
+
+        await port.stop()
+
+        self.assertEqual([call(None)], mock.call_args_list)
 
 
 if __name__ == "__main__":

packages/core/minos-microservice-common/tests/test_common/test_setup.py

@@ -73,11 +73,11 @@ def test_from_config_file_path(self):
     async def test_from_config_with_dependency_injection(self):
         config = Config(BASE_PATH / "test_config.yml")
         injector = DependencyInjector(config)
-        await injector.wire_and_setup(modules=[sys.modules[__name__]])
+        await injector.wire_and_setup_injections(modules=[sys.modules[__name__]])
 
         _SetupMixin.from_config()
 
-        await injector.unwire_and_destroy()
+        await injector.unwire_and_destroy_injections()
 
     def test_from_config_raises(self):
         with self.assertRaises(NotProvidedException):