ISSUE #371

* Increase coverage (2).

Author: Sergio García Prado

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

@@ -100,52 +100,52 @@ def _get_injections(self) -> list[Union[InjectableMixin, type[InjectableMixin]]]
     def _get_databases(self) -> dict[str, dict[str, Any]]:
         data = deepcopy(self.get_by_key("databases"))
         for database in data.values():
-            if "client" in database:
+            if database.get("client") is not None:
                 database["client"] = import_module(database["client"])
         return data
 
     def _get_interfaces(self) -> dict[str, dict[str, Any]]:
         data = deepcopy(self.get_by_key("interfaces"))
 
-        if "http" in data:
+        if data.get("http") is not None:
             data["http"] = self._parse_http_interface(data["http"])
-        if "broker" in data:
+        if data.get("broker") is not None:
             data["broker"] = self._parse_broker_interface(data["broker"])
-        if "periodic" in data:
+        if data.get("periodic") is not None:
             data["periodic"] = self._parse_periodic_interface(data["periodic"])
 
         return data
 
     @staticmethod
     def _parse_http_interface(data: dict[str, Any]) -> dict[str, Any]:
-        if "port" in data:
+        if data.get("port") is not None:
             data["port"] = import_module(data["port"])
-        if "connector" in data:
+        if data.get("connector") is not None:
             data["connector"]["client"] = import_module(data["connector"]["client"])
         return data
 
     @staticmethod
     def _parse_broker_interface(data: dict[str, Any]) -> dict[str, Any]:
-        if "port" in data:
+        if data.get("port") is not None:
             data["port"] = import_module(data["port"])
 
-        if "publisher" in data:
+        if data.get("publisher") is not None:
             data["publisher"]["client"] = import_module(data["publisher"]["client"])
-            if "queue" in data["publisher"]:
+            if data["publisher"].get("queue") is not None:
                 data["publisher"]["queue"] = import_module(data["publisher"]["queue"])
 
-        if "subscriber" in data:
+        if data.get("subscriber") is not None:
             data["subscriber"]["client"] = import_module(data["subscriber"]["client"])
-            if "queue" in data["subscriber"]:
+            if data["subscriber"].get("queue") is not None:
                 data["subscriber"]["queue"] = import_module(data["subscriber"]["queue"])
-            if "validator" in data["subscriber"]:
+            if data["subscriber"].get("validator") is not None:
                 data["subscriber"]["validator"] = import_module(data["subscriber"]["validator"])
 
         return data
 
     @staticmethod
     def _parse_periodic_interface(data: dict[str, Any]) -> dict[str, Any]:
-        if "port" in data:
+        if data.get("port") is not None:
             data["port"] = import_module(data["port"])
 
         return data

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

@@ -78,8 +78,6 @@ def _get_generic_operation_factory(self) -> Optional[type[GenericDatabaseOperati
             if origin is None or not issubclass(origin, DatabaseMixin):
                 continue
             args = get_args(base)
-            if not len(args):
-                continue
             operation_factory_cls = args[0]
             if not isinstance(operation_factory_cls, type) or not issubclass(
                 operation_factory_cls, DatabaseOperationFactory

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

@@ -3,8 +3,10 @@
 from minos.common import (
     AiopgDatabaseClient,
     AiopgDatabaseOperation,
+    AiopgLockDatabaseOperationFactory,
     DatabaseClientPool,
     DatabaseMixin,
+    LockDatabaseOperationFactory,
     NotProvidedException,
     PoolFactory,
 )
@@ -39,6 +41,33 @@ async def test_pool(self):
         async with DatabaseMixin() as database:
             self.assertIsInstance(database.database_pool, DatabaseClientPool)
 
+    async def test_operation_factory(self):
+        operation_factory = AiopgLockDatabaseOperationFactory()
+        mixin = DatabaseMixin(operation_factory=operation_factory)
+        self.assertEqual(operation_factory, mixin.operation_factory)
+
+    async def test_operation_factory_from_cls_init(self):
+        mixin = DatabaseMixin(operation_factory_cls=LockDatabaseOperationFactory)
+        self.assertIsInstance(mixin.operation_factory, AiopgLockDatabaseOperationFactory)
+
+    async def test_operation_factory_from_cls_generic(self):
+        class _DatabaseMixin(DatabaseMixin[LockDatabaseOperationFactory]):
+            """For testing purposes."""
+
+        mixin = _DatabaseMixin()
+        self.assertIsInstance(mixin.operation_factory, AiopgLockDatabaseOperationFactory)
+
+    async def test_operation_factory_none(self):
+        mixin = DatabaseMixin()
+        self.assertEqual(None, mixin.operation_factory)
+
+    async def test_operation_factory_from_cls_generic_raises(self):
+        class _DatabaseMixin(DatabaseMixin[int]):
+            """For testing purposes."""
+
+        with self.assertRaises(TypeError):
+            _DatabaseMixin()
+
     async def test_submit_query(self):
         op1 = AiopgDatabaseOperation("CREATE TABLE foo (id INT NOT NULL);")
         op2 = AiopgDatabaseOperation("SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = 'foo');")

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

@@ -0,0 +1,48 @@
+import unittest
+from abc import (
+    ABC,
+)
+
+from minos.common import (
+    ComposedDatabaseOperation,
+    DatabaseOperation,
+    DatabaseOperationFactory,
+)
+
+
+class _DatabaseOperation(DatabaseOperation):
+    """For testing purposes."""
+
+
+class TestDatabaseOperation(unittest.TestCase):
+    def test_abstract(self):
+        self.assertTrue(issubclass(DatabaseOperation, ABC))
+
+    def test_constructor(self):
+        operation = _DatabaseOperation()
+        self.assertEqual(None, operation.timeout)
+        self.assertEqual(None, operation.lock)
+
+    def test_constructor_extended(self):
+        operation = _DatabaseOperation(timeout=3, lock="foo")
+        self.assertEqual(3, operation.timeout)
+        self.assertEqual("foo", operation.lock)
+
+
+class TestComposedDatabaseOperation(unittest.TestCase):
+    def test_subclass(self) -> None:
+        self.assertTrue(issubclass(ComposedDatabaseOperation, DatabaseOperation))
+
+    def test_constructor(self):
+        operations = [_DatabaseOperation(), _DatabaseOperation()]
+        composed = ComposedDatabaseOperation(operations)
+        self.assertEqual(tuple(operations), composed.operations)
+
+
+class TestDatabaseOperationFactory(unittest.TestCase):
+    def test_abstract(self):
+        self.assertTrue(issubclass(DatabaseOperationFactory, ABC))
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,22 @@
+import unittest
+
+from minos.common import (
+    AiopgDatabaseOperation,
+    DatabaseOperation,
+)
+
+
+class TestAiopgDatabaseOperation(unittest.TestCase):
+    def test_subclass(self) -> None:
+        self.assertTrue(issubclass(AiopgDatabaseOperation, DatabaseOperation))
+
+    def test_constructor(self):
+        operation = AiopgDatabaseOperation("query", {"foo": "bar"})
+        self.assertEqual("query", operation.query)
+        self.assertEqual({"foo": "bar"}, operation.parameters)
+        self.assertEqual(None, operation.timeout)
+        self.assertEqual(None, operation.lock)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -5,17 +5,20 @@
 
 from minos.common import (
     AiopgDatabaseClient,
+    Config,
     DatabaseClient,
     DatabaseClientBuilder,
     DatabaseClientPool,
     DatabaseLock,
     DatabaseLockPool,
     UnableToConnectException,
+    classname,
 )
 from minos.common.testing import (
     DatabaseMinosTestCase,
 )
 from tests.utils import (
+    CONFIG_FILE_PATH,
     CommonTestCase,
 )
 
@@ -43,6 +46,16 @@ def test_from_config(self):
         self.assertIsInstance(pool.client_builder, DatabaseClientBuilder)
         self.assertEqual(AiopgDatabaseClient, pool.client_builder.instance_cls)
 
+    def test_from_config_client_builder(self):
+        config = Config(CONFIG_FILE_PATH, databases_default_client=classname(DatabaseClientBuilder))
+        pool = DatabaseClientPool.from_config(config)
+        self.assertIsInstance(pool.client_builder, DatabaseClientBuilder)
+
+    def test_from_config_client_none(self):
+        config = Config(CONFIG_FILE_PATH, databases_default_client=None)
+        with self.assertRaises(ValueError):
+            DatabaseClientPool.from_config(config)
+
     async def test_acquire_once(self):
         async with self.pool.acquire() as c1:
             self.assertIsInstance(c1, DatabaseClient)