ISSUE #346

* Increase coverage.
* Fix bug related with `PostgresAsyncTestCase`.

Author: Sergio García Prado

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

@@ -90,7 +90,9 @@ def _get_pool_class(self, type_: str) -> type[Pool]:
             pool_cls = self._config.get_pools().get(type_)
 
         if pool_cls is None:
-            raise ValueError
+            raise ValueError(
+                f"There is not any provided {type!r} to build pools that matches the given type: {type_!r}"
+            )
 
         return pool_cls
 

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

@@ -1,13 +1,11 @@
 import unittest
+import warnings
 from abc import (
     ABC,
 )
 from contextlib import (
     suppress,
 )
-from itertools import (
-    starmap,
-)
 from pathlib import (
     Path,
 )
@@ -77,21 +75,24 @@ def __getattr__(self, item: str) -> Any:
 # noinspection SqlNoDataSourceInspection
 class PostgresAsyncTestCase(MinosTestCase, ABC):
     def setUp(self):
-        self._config = Config(self.get_config_file_path())
+        self.base_config = Config(self.get_config_file_path())
         self._uuid = uuid4()
         self._test_db = {"database": f"test_db_{self._uuid.hex}", "user": f"test_user_{self._uuid.hex}"}
         super().setUp()
 
     @property
     def repository_db(self) -> dict[str, Any]:
+        warnings.warn("'repository_db' attribute has been deprecated.", DeprecationWarning)
         return self.config.get_database_by_name("aggregate") | self._test_db
 
     @property
     def broker_queue_db(self) -> dict[str, Any]:
+        warnings.warn("'broker_queue_db' attribute has been deprecated.", DeprecationWarning)
         return self.config.get_database_by_name("broker") | self._test_db
 
     @property
     def snapshot_db(self) -> dict[str, Any]:
+        warnings.warn("'snapshot_db' attribute has been deprecated.", DeprecationWarning)
         return self.config.get_database_by_name("aggregate") | self._test_db
 
     def get_config(self) -> Config:
@@ -109,15 +110,15 @@ def get_injections(self) -> list[Union[InjectableMixin, type[InjectableMixin], s
         return [PoolFactory.from_config(self.config, default_classes={"database": DatabaseClientPool})]
 
     async def asyncSetUp(self):
-        pairs = self._drop_duplicates(
-            [(db, self._test_db) for db in self._config.get_databases().values() if "database" in db]
-        )
+        await self._create_database(self.base_config.get_default_database(), self._test_db)
+        await super().asyncSetUp()
 
-        for meta, test in pairs:
-            await self._setup_database(meta, test)
+    async def asyncTearDown(self):
+        await super().asyncTearDown()
+        await self._drop_database(self.base_config.get_default_database(), self._test_db)
 
-    async def _setup_database(self, meta: dict[str, Any], test: dict[str, Any]) -> None:
-        await self._teardown_database(meta, test)
+    async def _create_database(self, meta: dict[str, Any], test: dict[str, Any]) -> None:
+        await self._drop_database(meta, test)
 
         async with aiopg.connect(**meta) as connection:
             async with connection.cursor() as cursor:
@@ -127,28 +128,8 @@ async def _setup_database(self, meta: dict[str, Any], test: dict[str, Any]) -> N
                 template = "CREATE DATABASE {database} WITH OWNER = {user};"
                 await cursor.execute(template.format(**(meta | test)))
 
-        await super().asyncSetUp()
-
-    async def asyncTearDown(self):
-        await super().asyncTearDown()
-
-        pairs = self._drop_duplicates(
-            [(db, self._test_db) for db in self._config.get_databases().values() if "database" in db]
-        )
-
-        for meta, test in pairs:
-            await self._teardown_database(meta, test)
-
-    @staticmethod
-    def _drop_duplicates(items: list[(dict, dict)]):
-        items = starmap(lambda a, b: (tuple(a.items()), tuple(b.items())), items)
-        items = set(items)
-        items = starmap(lambda a, b: (dict(a), dict(b)), items)
-        items = list(items)
-        return items
-
     @staticmethod
-    async def _teardown_database(meta: dict[str, Any], test: dict[str, Any]) -> None:
+    async def _drop_database(meta: dict[str, Any], test: dict[str, Any]) -> None:
         async with aiopg.connect(**meta) as connection:
             async with connection.cursor() as cursor:
                 template = "DROP DATABASE IF EXISTS {database}"

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

@@ -1,11 +1,14 @@
 import unittest
+import warnings
 
 import aiopg
 
 from minos.common import (
     DatabaseClientPool,
     DatabaseMixin,
+    NotProvidedException,
     PoolFactory,
+    PostgreSqlMinosDatabase,
 )
 from minos.common.testing import (
     PostgresAsyncTestCase,
@@ -29,6 +32,11 @@ async def test_constructor_with_pool_factory(self):
         # noinspection PyUnresolvedReferences
         self.assertEqual(pool_factory.get_pool("database"), database.pool)
 
+    async def test_constructor_raises(self):
+        with self.assertRaises(NotProvidedException):
+            # noinspection PyArgumentEqualDefault
+            DatabaseMixin(pool=None, pool_factory=None)
+
     def test_database(self):
         pool = DatabaseClientPool.from_config(self.config)
         database = DatabaseMixin(pool)
@@ -113,5 +121,18 @@ async def test_submit_query_and_iter_locked(self):
         self.assertEqual([(3,), (4,), (5,)], observed)
 
 
+class TestPostgreSqlMinosDatabase(CommonTestCase, PostgresAsyncTestCase):
+    def test_is_subclass(self):
+        self.assertTrue(issubclass(PostgreSqlMinosDatabase, DatabaseMixin))
+
+    def test_warnings(self):
+        pool = DatabaseClientPool.from_config(self.config)
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            database = PostgreSqlMinosDatabase(pool)
+            self.assertIsInstance(database, DatabaseMixin)
+
+
 if __name__ == "__main__":
     unittest.main()

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

@@ -1,4 +1,5 @@
 import unittest
+import warnings
 
 import aiopg
 from aiopg import (
@@ -8,6 +9,7 @@
 from minos.common import (
     DatabaseLock,
     Lock,
+    PostgreSqlLock,
 )
 from minos.common.testing import (
     PostgresAsyncTestCase,
@@ -17,7 +19,7 @@
 )
 
 
-class TestPostgreSqlLock(CommonTestCase, PostgresAsyncTestCase):
+class TestDatabaseLock(CommonTestCase, PostgresAsyncTestCase):
     def test_base(self):
         self.assertTrue(issubclass(DatabaseLock, Lock))
 
@@ -47,5 +49,18 @@ async def test_cursor(self):
             self.assertIsInstance(lock.cursor, Cursor)
 
 
+class TestPostgreSqlLock(CommonTestCase, PostgresAsyncTestCase):
+    def test_is_subclass(self):
+        self.assertTrue(issubclass(PostgreSqlLock, DatabaseLock))
+
+    async def test_warnings(self):
+        wrapped_connection = aiopg.connect(**self.config.get_default_database())
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            lock = PostgreSqlLock(wrapped_connection, "foo")
+            self.assertIsInstance(lock, DatabaseLock)
+
+
 if __name__ == "__main__":
     unittest.main()

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

@@ -1,4 +1,5 @@
 import unittest
+import warnings
 from unittest.mock import (
     PropertyMock,
     patch,
@@ -16,6 +17,8 @@
     DatabaseClientPool,
     DatabaseLock,
     DatabaseLockPool,
+    PostgreSqlLockPool,
+    PostgreSqlPool,
 )
 from minos.common.testing import (
     PostgresAsyncTestCase,
@@ -25,7 +28,7 @@
 )
 
 
-class TestPostgreSqlPool(CommonTestCase, PostgresAsyncTestCase):
+class TestDatabaseClientPool(CommonTestCase, PostgresAsyncTestCase):
     def setUp(self) -> None:
         super().setUp()
         self.pool = DatabaseClientPool.from_config(self.config)
@@ -80,7 +83,18 @@ def _side_effect(*args, **kwargs):
                 self.assertIsInstance(connection, Connection)
 
 
-class TestPostgreSqlLockPool(CommonTestCase, PostgresAsyncTestCase):
+class TestPostgreSqlPool(CommonTestCase, PostgresAsyncTestCase):
+    def test_is_subclass(self):
+        self.assertTrue(issubclass(PostgreSqlPool, DatabaseClientPool))
+
+    def test_warnings(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            pool = PostgreSqlPool.from_config(self.config)
+            self.assertIsInstance(pool, DatabaseClientPool)
+
+
+class TestDatabaseLockPool(CommonTestCase, PostgresAsyncTestCase):
     def setUp(self) -> None:
         super().setUp()
         self.pool = DatabaseLockPool.from_config(self.config)
@@ -99,5 +113,16 @@ async def test_acquire(self):
             self.assertEqual("foo", lock.key)
 
 
+class TestPostgreSqlLockPool(CommonTestCase, PostgresAsyncTestCase):
+    def test_is_subclass(self):
+        self.assertTrue(issubclass(PostgreSqlLockPool, DatabaseLockPool))
+
+    def test_warnings(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            pool = PostgreSqlLockPool.from_config(self.config)
+            self.assertIsInstance(pool, DatabaseLockPool)
+
+
 if __name__ == "__main__":
     unittest.main()

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

@@ -1,21 +1,19 @@
 import unittest
+import warnings
 
 from minos.common import (
     Config,
     DependencyInjector,
 )
 from minos.common.testing import (
     MinosTestCase,
+    PostgresAsyncTestCase,
 )
 from tests.utils import (
     CONFIG_FILE_PATH,
 )
 
 
-class MyMinosTestCase(MinosTestCase):
-    CONFIG_FILE_PATH = CONFIG_FILE_PATH
-
-
 class TestMinosTestCase(unittest.IsolatedAsyncioTestCase):
     def test_config(self):
         test_case = MyMinosTestCase()
@@ -28,5 +26,81 @@ def test_injector(self):
         self.assertIsInstance(test_case.injector, DependencyInjector)
 
 
+class MyMinosTestCase(MinosTestCase):
+    CONFIG_FILE_PATH = CONFIG_FILE_PATH
+
+
+class TestPostgresAsyncTestCase(unittest.IsolatedAsyncioTestCase):
+    def test_repository_db(self):
+        test_case = MyPostgresAsyncTestCase()
+        test_case.setUp()
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            self.assertEqual(
+                {
+                    k: v
+                    for k, v in test_case.base_config.get_database_by_name("aggregate").items()
+                    if k not in {"database", "user"}
+                },
+                {k: v for k, v in test_case.repository_db.items() if k not in {"database", "user"}},
+            )
+            self.assertNotEqual(
+                test_case.base_config.get_database_by_name("aggregate")["database"],
+                test_case.repository_db["database"],
+            )
+            self.assertNotEqual(
+                test_case.base_config.get_database_by_name("aggregate")["user"],
+                test_case.repository_db["user"],
+            )
+
+    def test_broker_queue_db(self):
+        test_case = MyPostgresAsyncTestCase()
+        test_case.setUp()
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            self.assertEqual(
+                {
+                    k: v
+                    for k, v in test_case.base_config.get_database_by_name("broker").items()
+                    if k not in {"database", "user"}
+                },
+                {k: v for k, v in test_case.broker_queue_db.items() if k not in {"database", "user"}},
+            )
+            self.assertNotEqual(
+                test_case.base_config.get_database_by_name("broker")["database"],
+                test_case.broker_queue_db["database"],
+            )
+            self.assertNotEqual(
+                test_case.base_config.get_database_by_name("broker")["user"],
+                test_case.broker_queue_db["user"],
+            )
+
+    def test_snapshot_db(self):
+        test_case = MyPostgresAsyncTestCase()
+        test_case.setUp()
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            self.assertEqual(
+                {
+                    k: v
+                    for k, v in test_case.base_config.get_database_by_name("aggregate").items()
+                    if k not in {"database", "user"}
+                },
+                {k: v for k, v in test_case.snapshot_db.items() if k not in {"database", "user"}},
+            )
+            self.assertNotEqual(
+                test_case.base_config.get_database_by_name("aggregate")["database"],
+                test_case.broker_queue_db["database"],
+            )
+            self.assertNotEqual(
+                test_case.base_config.get_database_by_name("aggregate")["user"],
+                test_case.broker_queue_db["user"],
+            )
+
+
+class MyPostgresAsyncTestCase(PostgresAsyncTestCase):
+    CONFIG_FILE_PATH = CONFIG_FILE_PATH
+
+
 if __name__ == "__main__":
     unittest.main()