ISSUE #346

* Fix all broken tests.

Author: Sergio García Prado

packages/core/minos-microservice-common/minos/common/config/v1.py

@@ -128,21 +128,7 @@ def _get_injections(self) -> list[type[InjectableMixin]]:
         except MinosConfigException:
             injections = list()
 
-        old = [import_module(classname) for classname in injections]
-        from ..injections import (
-            InjectableMixin,
-        )
-        from ..pools import (
-            PoolFactory,
-        )
-
-        injections = list()
-        injections.append(PoolFactory)  # FIXME
-
-        for type_ in old:
-            if not issubclass(type_, InjectableMixin):
-                continue
-            injections.append(type_)
+        injections = [import_module(classname) for classname in injections]
 
         # noinspection PyTypeChecker
         return injections
@@ -231,36 +217,7 @@ def _get_services(self) -> list[type]:
         return services
 
     def _get_pools(self) -> dict[str, type]:
-        try:
-            pools = self.get_by_key("service.injections")
-        except Exception:
-            pools = list()
-
-        if isinstance(pools, dict):
-            pools = list(pools.values())
-
-        old = [import_module(classname) for classname in pools]
-
-        from ..pools import (
-            Pool,
-        )
-
-        pools = dict()
-
-        for type_ in old:
-            if not issubclass(type_, Pool):
-                continue
-            label = "unknown"
-            if "lock" in type_.__name__.lower():
-                label = "lock"
-            elif "postgres" in type_.__name__.lower():
-                label = "database"
-            elif "broker" in type_.__name__.lower():
-                label = "broker"
-
-            pools[label] = type_
-
-        return pools
+        return dict()
 
     def _get_routers(self) -> list[type]:
         try:

packages/core/minos-microservice-common/minos/common/config/v2.py

@@ -50,14 +50,8 @@ def _get_injections(self) -> list[Union[InjectableMixin, type[InjectableMixin]]]
 
         partial_ans = list()
 
-        from ..pools import (
-            PoolFactory,
-        )
-
-        partial_ans.append(PoolFactory)  # FIXME
-
         with suppress(MinosConfigException):
-            partial_ans.extend(self._get_pools().values())
+            partial_ans.append(self._get_pools().get("factory"))
 
         with suppress(MinosConfigException):
             partial_ans.append(self._get_interfaces().get("http").get("connector"))
@@ -96,7 +90,7 @@ def _get_injections(self) -> list[Union[InjectableMixin, type[InjectableMixin]]]
             ):
                 type_ = builder_type
             elif not issubclass(type_, InjectableMixin):
-                continue  # raise MinosConfigException(f"{type_!r} must be subclass of {InjectableMixin!r}.")
+                raise MinosConfigException(f"{type_!r} must be subclass of {InjectableMixin!r}.")
 
             ans.append(type_)
 
@@ -154,14 +148,22 @@ def _parse_periodic_interface(data: dict[str, Any]) -> dict[str, Any]:
         return data
 
     def _get_pools(self) -> dict[str, type]:
+        from ..pools import (
+            PoolFactory,
+        )
+        factory = PoolFactory
+
         try:
-            data = self.get_by_key("pools")
+            types = self.get_by_key("pools")
         except MinosConfigException:
-            data = dict()
+            types = dict()
 
-        data = {name: import_module(classname) for name, classname in data.items()}
+        types = {name: import_module(classname) for name, classname in types.items()}
 
-        return data
+        return {
+            "factory": factory,
+            "types": types,
+        }
 
     def _get_routers(self) -> list[type]:
         try:

packages/core/minos-microservice-common/minos/common/database/pools.py

@@ -21,6 +21,7 @@
     OperationalError,
 )
 
+from ..injections import Injectable
 from ..locks import (
     LockPool,
 )
@@ -119,6 +120,7 @@ def acquire(self, key: Hashable, *args, **kwargs) -> DatabaseLock:
         return DatabaseLock(super().acquire(), key, *args, **kwargs)
 
 
+@Injectable("postgresql_pool")
 class PostgreSqlLockPool(DatabaseLockPool):
     """TODO"""
 

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

@@ -16,6 +16,9 @@
     cached_property,
 )
 
+from .injections import (
+    Injectable,
+)
 from .pools import (
     Pool,
 )
@@ -43,5 +46,6 @@ def hashed_key(self) -> int:
         return self.key
 
 
+@Injectable("lock_pool")
 class LockPool(Pool[Lock], ABC):
     """Postgres Locking Pool class."""

packages/core/minos-microservice-common/tests/test_common/test_config/test_v1/test_base.py

@@ -6,7 +6,7 @@
 from minos.common import (
     Config,
     ConfigV1,
-    MinosConfigException,
+    MinosConfigException, PoolFactory,
 )
 from tests.utils import (
     BASE_PATH,

packages/core/minos-microservice-common/tests/test_common/test_config/test_v2/test_base.py

@@ -1,8 +1,4 @@
 import unittest
-from itertools import (
-    chain,
-    cycle,
-)
 from unittest.mock import (
     patch,
 )
@@ -62,9 +58,6 @@ def test_name(self):
     def test_injections(self):
         expected = [
             PoolFactory,
-            FakeLockPool,
-            FakeDatabasePool,
-            FakeBrokerClientPool,
             FakeHttpConnector,
             FakeBrokerPublisher,
             FakeBrokerSubscriberBuilder(FakeBrokerSubscriber),
@@ -82,8 +75,7 @@ def test_injections_not_defined(self):  # FIXME
             self.assertEqual([PoolFactory], self.config.get_injections())
 
     def test_injections_not_injectable(self):
-        side_effect = chain([{"client": "builtins.int"}], cycle([MinosConfigException("")]))
-        with patch.object(ConfigV2, "get_by_key", side_effect=side_effect):
+        with patch.object(ConfigV2, "_get_pools", return_value={"factory": int}):
             with self.assertRaises(MinosConfigException):
                 self.config.get_injections()
 
@@ -147,15 +139,19 @@ def test_interface_unknown(self):
 
     def test_pools(self):
         expected = {
-            "broker": FakeBrokerClientPool,
-            "database": FakeDatabasePool,
-            "lock": FakeLockPool,
+            "factory": PoolFactory,
+            "types": {
+                "broker": FakeBrokerClientPool,
+                "database": FakeDatabasePool,
+                "lock": FakeLockPool,
+            }
         }
         self.assertEqual(expected, self.config.get_pools())
 
     def test_pools_not_defined(self):
+        expected = {"factory": PoolFactory, "types": {}}
         with patch.object(ConfigV2, "get_by_key", side_effect=MinosConfigException("")):
-            self.assertEqual(dict(), self.config.get_pools())
+            self.assertEqual(expected, self.config.get_pools())
 
     def test_services(self):
         self.assertEqual([float, int], self.config.get_services())

packages/core/minos-microservice-common/tests/test_common/test_config/test_v2/test_parameterized.py

@@ -39,9 +39,6 @@ def test_injections_nones(self):
 
         expected = [
             PoolFactory,
-            FakeLockPool,
-            FakeDatabasePool,
-            FakeBrokerClientPool,
             FakeBrokerPublisher,
             FakeBrokerSubscriberBuilder(FakeBrokerSubscriber),
             FakeEventRepository,

packages/core/minos-microservice-networks/minos/networks/brokers/pools.py

@@ -14,6 +14,7 @@
 
 from minos.common import (
     Config,
+    Injectable,
     Pool,
 )
 
@@ -27,16 +28,12 @@
 logger = logging.getLogger(__name__)
 
 
+@Injectable("broker_pool")
 class BrokerClientPool(Pool):
     """Broker Client Pool class."""
 
     def __init__(
-        self,
-        instance_kwargs: dict[str, Any],
-        maxsize: int = 5,
-        recycle: Optional[int] = 3600,
-        *args,
-        **kwargs,
+        self, instance_kwargs: dict[str, Any], maxsize: int = 5, recycle: Optional[int] = 3600, *args, **kwargs
     ):
         super().__init__(maxsize=maxsize, recycle=recycle, *args, **kwargs)
         self._instance_kwargs = instance_kwargs