ISSUE #?

* Fix warnings.

Author: Sergio García Prado

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

@@ -20,25 +20,25 @@
 
 # noinspection SqlNoDataSourceInspection,SqlResolve
 class TestDatabaseMixin(CommonTestCase, DatabaseMinosTestCase):
-    def test_constructor(self):
-        pool = DatabaseClientPool.from_config(self.config)
-        # noinspection PyTypeChecker
-        database = DatabaseMixin(pool)
-        self.assertEqual(pool, database.database_pool)
+    async def test_constructor(self):
+        async with DatabaseClientPool.from_config(self.config) as pool:
+            # noinspection PyTypeChecker
+            database = DatabaseMixin(pool)
+            self.assertEqual(pool, database.database_pool)
 
     async def test_constructor_with_pool_factory(self):
-        pool_factory = PoolFactory(self.config, {"database": DatabaseClientPool})
-        # noinspection PyTypeChecker
-        database = DatabaseMixin(pool_factory=pool_factory)
-        # noinspection PyUnresolvedReferences
-        self.assertEqual(pool_factory.get_pool("database"), database.database_pool)
+        async with PoolFactory(self.config, {"database": DatabaseClientPool}) as pool_factory:
+            # noinspection PyTypeChecker
+            database = DatabaseMixin(pool_factory=pool_factory)
+            # noinspection PyUnresolvedReferences
+            self.assertEqual(pool_factory.get_pool("database"), database.database_pool)
 
     async def test_constructor_with_pool_factory_and_database_key(self):
-        pool_factory = PoolFactory(self.config, {"database": DatabaseClientPool})
-        # noinspection PyTypeChecker
-        database = DatabaseMixin(pool_factory=pool_factory, database_key=("query", "unknown"))
-        # noinspection PyUnresolvedReferences
-        self.assertEqual(pool_factory.get_pool("database", "query"), database.database_pool)
+        async with PoolFactory(self.config, {"database": DatabaseClientPool}) as pool_factory:
+            # noinspection PyTypeChecker
+            database = DatabaseMixin(pool_factory=pool_factory, database_key=("query", "unknown"))
+            # noinspection PyUnresolvedReferences
+            self.assertEqual(pool_factory.get_pool("database", "query"), database.database_pool)
 
     async def test_constructor_raises(self):
         with self.assertRaises(NotProvidedException):

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

@@ -28,10 +28,10 @@ def setUp(self) -> None:
         super().setUp()
         self.pool = DatabaseClientPool.from_config(self.config)
 
-    def test_constructor(self):
+    async def test_constructor(self):
         builder = DatabaseClientBuilder()
-        pool = DatabaseClientPool(builder)
-        self.assertEqual(builder, pool.client_builder)
+        async with DatabaseClientPool(builder) as pool:
+            self.assertEqual(builder, pool.client_builder)
 
     async def asyncSetUp(self):
         await super().asyncSetUp()
@@ -41,15 +41,15 @@ async def asyncTearDown(self):
         await self.pool.destroy()
         await super().asyncTearDown()
 
-    def test_from_config(self):
-        pool = DatabaseClientPool.from_config(self.config, key="event")
-        self.assertIsInstance(pool.client_builder, DatabaseClientBuilder)
-        self.assertEqual(MockedDatabaseClient, pool.client_builder.instance_cls)
+    async def test_from_config(self):
+        async with DatabaseClientPool.from_config(self.config, key="event") as pool:
+            self.assertIsInstance(pool.client_builder, DatabaseClientBuilder)
+            self.assertEqual(MockedDatabaseClient, pool.client_builder.instance_cls)
 
-    def test_from_config_client_builder(self):
+    async 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)
+        async with DatabaseClientPool.from_config(config) as pool:
+            self.assertIsInstance(pool.client_builder, DatabaseClientBuilder)
 
     def test_from_config_client_none(self):
         config = Config(CONFIG_FILE_PATH, databases_default_client=None)

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

@@ -36,13 +36,18 @@ def setUp(self):
         super().setUp()
         self.factory = PoolFactory(self.config, {"lock": FakeLockPool})
 
-    def test_from_config(self):
-        self.assertIsInstance(PoolFactory.from_config(self.config), PoolFactory)
+    async def asyncSetUp(self):
+        await super().asyncSetUp()
+        await self.factory.setup()
 
     async def asyncTearDown(self):
         await self.factory.destroy()
         await super().asyncTearDown()
 
+    async def test_from_config(self):
+        async with PoolFactory.from_config(self.config) as pool_factory:
+            self.assertIsInstance(pool_factory, PoolFactory)
+
     def test_get_pool(self):
         lock = self.factory.get_pool("lock")
         self.assertIsInstance(lock, FakeLockPool)
@@ -119,11 +124,11 @@ class TestMinosPool(unittest.IsolatedAsyncioTestCase):
     def test_is_subclass(self):
         self.assertTrue(issubclass(MinosPool, SetupMixin))
 
-    def test_warnings(self):
+    async def test_warnings(self):
         with warnings.catch_warnings():
             warnings.simplefilter("ignore", DeprecationWarning)
-            setup = _MinosPool()
-            self.assertIsInstance(setup, SetupMixin)
+            async with _MinosPool() as setup:
+                self.assertIsInstance(setup, SetupMixin)
 
 
 class _MinosPool(MinosPool):

packages/core/minos-microservice-cqrs/tests/test_cqrs/test_services.py

@@ -46,6 +46,14 @@ def setUp(self) -> None:
 
         self.service = FakeService(config=self.config, lock_pool=self.lock_pool)
 
+    async def asyncSetUp(self):
+        await super().asyncSetUp()
+        await self.lock_pool.setup()
+
+    async def asyncTearDown(self) -> None:
+        await self.lock_pool.destroy()
+        await super().asyncTearDown()
+
     def tearDown(self) -> None:
         self.injector.unwire_injections()
         super().tearDown()

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

@@ -50,12 +50,24 @@
 class NetworksTestCase(MinosTestCase, ABC):
     testing_module = testing
 
+    def setUp(self) -> None:
+        self.lock_pool = FakeLockPool()
+        super().setUp()
+
+    async def asyncSetUp(self) -> None:
+        await self.lock_pool.setup()
+        await super().asyncSetUp()
+
+    async def asyncTearDown(self) -> None:
+        await super().asyncTearDown()
+        await self.lock_pool.destroy()
+
     def get_config_file_path(self):
         return CONFIG_FILE_PATH
 
     def get_injections(self) -> list[Union[InjectableMixin, type[InjectableMixin], str]]:
         injections = [
-            InMemoryTransactionRepository(lock_pool=FakeLockPool()),
+            InMemoryTransactionRepository(lock_pool=self.lock_pool),
         ]
         # noinspection PyTypeChecker
         return super().get_injections() + injections