ISSUE #346

* Refactor `PostgresAsyncTestCase`.

Author: Sergio García Prado

packages/core/minos-microservice-aggregate/tests/test_aggregate/test_events/test_repositories/test_pg.py

@@ -21,9 +21,10 @@
 class TestPostgreSqlEventRepositorySubmit(EventRepositorySubmitTestCase, PostgresAsyncTestCase):
     __test__ = True
 
-    def build_event_repository(self) -> EventRepository:
+    @staticmethod
+    def build_event_repository() -> EventRepository:
         """Fort testing purposes."""
-        return PostgreSqlEventRepository(**self.repository_db)
+        return PostgreSqlEventRepository()
 
     def test_constructor(self):
         pool = DatabaseClientPool.from_config(self.config)
@@ -41,7 +42,7 @@ def test_from_config(self):
         self.assertEqual(repository_config["port"], repository.port)
 
     async def test_setup(self):
-        async with aiopg.connect(**self.repository_db) as connection:
+        async with aiopg.connect(**self.config.get_default_database()) as connection:
             async with connection.cursor() as cursor:
                 await cursor.execute(
                     "SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = 'aggregate_event');"
@@ -53,9 +54,10 @@ async def test_setup(self):
 class TestPostgreSqlRepositorySelect(EventRepositorySelectTestCase, PostgresAsyncTestCase):
     __test__ = True
 
-    def build_event_repository(self) -> EventRepository:
+    @staticmethod
+    def build_event_repository() -> EventRepository:
         """Fort testing purposes."""
-        return PostgreSqlEventRepository(**self.repository_db)
+        return PostgreSqlEventRepository()
 
 
 if __name__ == "__main__":

packages/core/minos-microservice-aggregate/tests/test_aggregate/test_snapshots/test_pg/test_abc.py

@@ -16,7 +16,7 @@
 class TestPostgreSqlSnapshotSetup(AggregateTestCase, PostgresAsyncTestCase):
     async def test_setup_snapshot_table(self):
         async with PostgreSqlSnapshotSetup.from_config(self.config):
-            async with aiopg.connect(**self.snapshot_db) as connection:
+            async with aiopg.connect(**self.config.get_default_database()) as connection:
                 async with connection.cursor() as cursor:
                     await cursor.execute(
                         "SELECT EXISTS (SELECT FROM pg_tables "
@@ -27,7 +27,7 @@ async def test_setup_snapshot_table(self):
 
     async def test_setup_snapshot_aux_offset_table(self):
         async with PostgreSqlSnapshotSetup.from_config(self.config):
-            async with aiopg.connect(**self.snapshot_db) as connection:
+            async with aiopg.connect(**self.config.get_default_database()) as connection:
                 async with connection.cursor() as cursor:
                     await cursor.execute(
                         "SELECT EXISTS (SELECT FROM pg_tables WHERE "

packages/core/minos-microservice-aggregate/tests/test_aggregate/test_snapshots/test_pg/test_queries.py

@@ -426,7 +426,7 @@ async def test_build_complex(self):
         self.assertEqual(self._flatten_parameters(expected_parameters), self._flatten_parameters(observed[1]))
 
     async def _flatten_query(self, query) -> str:
-        async with aiopg.connect(**self.snapshot_db) as connection:
+        async with aiopg.connect(**self.config.get_default_database()) as connection:
             return query.as_string(connection.raw)
 
     @staticmethod

packages/core/minos-microservice-aggregate/tests/test_aggregate/test_transactions/test_repositories/test_pg.py

@@ -27,7 +27,7 @@ class TestPostgreSqlTransactionRepository(AggregateTestCase, PostgresAsyncTestCa
     def setUp(self) -> None:
         super().setUp()
 
-        self.transaction_repository = PostgreSqlTransactionRepository(**self.repository_db)
+        self.transaction_repository = PostgreSqlTransactionRepository()
 
         self.uuid = uuid4()
 
@@ -58,7 +58,7 @@ def test_from_config(self):
         self.assertEqual(repository_config["password"], repository.password)
 
     async def test_setup(self):
-        async with aiopg.connect(**self.repository_db) as connection:
+        async with aiopg.connect(**self.config.get_default_database()) as connection:
             async with connection.cursor() as cursor:
                 await cursor.execute(
                     "SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = 'aggregate_transaction');"
@@ -159,7 +159,7 @@ def setUp(self) -> None:
         self.uuid_4 = uuid4()
         self.uuid_5 = uuid4()
 
-        self.transaction_repository = PostgreSqlTransactionRepository(**self.repository_db)
+        self.transaction_repository = PostgreSqlTransactionRepository()
 
         self.entries = [
             TransactionEntry(self.uuid_1, TransactionStatus.PENDING, 12),

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

@@ -74,73 +74,66 @@ def __getattr__(self, item: str) -> Any:
         raise AttributeError(f"{type(self).__name__!r} does not contain the {item!r} attribute.")
 
 
+# noinspection SqlNoDataSourceInspection
 class PostgresAsyncTestCase(MinosTestCase, ABC):
     def setUp(self):
-
-        self._uuid = uuid4()
         self._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()
 
-        self._meta_repository_db = self._config.get_database_by_name("aggregate")
+    @property
+    def repository_db(self) -> dict[str, Any]:
+        return self.config.get_database_by_name("aggregate") | self._test_db
 
-        self._meta_broker_queue_db = self._config.get_database_by_name("broker")
+    @property
+    def broker_queue_db(self) -> dict[str, Any]:
+        return self.config.get_database_by_name("broker") | self._test_db
 
-        self._meta_snapshot_db = self._config.get_database_by_name("aggregate")
+    @property
+    def snapshot_db(self) -> dict[str, Any]:
+        return self.config.get_database_by_name("aggregate") | self._test_db
 
-        self._test_db = {"database": f"test_db_{self._uuid.hex}", "user": f"test_user_{self._uuid.hex}"}
+    def get_config(self) -> Config:
+        config = Config(self.get_config_file_path())
 
-        self.repository_db = self._meta_repository_db | self._test_db
-        self.broker_queue_db = self._meta_broker_queue_db | self._test_db
-        self.snapshot_db = self._meta_snapshot_db | self._test_db
+        base_fn = config.get_databases
 
-        super().setUp()
+        def _fn():
+            return {k: (v | self._test_db) for k, v in base_fn().items()}
 
-    def get_config(self) -> Config:
-        return Config(
-            self.get_config_file_path(),
-            repository_database=self.repository_db["database"],
-            repository_user=self.repository_db["user"],
-            broker_queue_database=self.broker_queue_db["database"],
-            broker_queue_user=self.broker_queue_db["user"],
-            snapshot_database=self.snapshot_db["database"],
-            snapshot_user=self.snapshot_db["user"],
-        )
+        config.get_databases = _fn
+        return config
 
     def get_injections(self) -> list[Union[InjectableMixin, type[InjectableMixin], str]]:
         return [PoolFactory.from_config(self.config, default_classes={"database": DatabaseClientPool})]
 
     async def asyncSetUp(self):
         pairs = self._drop_duplicates(
-            [
-                (self._meta_repository_db, self.repository_db),
-                (self._meta_broker_queue_db, self.broker_queue_db),
-                (self._meta_snapshot_db, self.snapshot_db),
-            ]
+            [(db, self._test_db) for db in self._config.get_databases().values() if "database" in db]
         )
+
         for meta, test in pairs:
-            await self._setup_database(dict(meta), dict(test))
+            await self._setup_database(meta, test)
 
     async def _setup_database(self, meta: dict[str, Any], test: dict[str, Any]) -> None:
         await self._teardown_database(meta, test)
 
         async with aiopg.connect(**meta) as connection:
             async with connection.cursor() as cursor:
                 template = "CREATE ROLE {user} WITH SUPERUSER CREATEDB LOGIN ENCRYPTED PASSWORD {password!r};"
-                await cursor.execute(template.format(**test))
+                await cursor.execute(template.format(**(meta | test)))
 
                 template = "CREATE DATABASE {database} WITH OWNER = {user};"
-                await cursor.execute(template.format(**test))
+                await cursor.execute(template.format(**(meta | test)))
 
         await super().asyncSetUp()
 
     async def asyncTearDown(self):
         await super().asyncTearDown()
 
         pairs = self._drop_duplicates(
-            [
-                (self._meta_repository_db, self.repository_db),
-                (self._meta_broker_queue_db, self.broker_queue_db),
-                (self._meta_snapshot_db, self.snapshot_db),
-            ]
+            [(db, self._test_db) for db in self._config.get_databases().values() if "database" in db]
         )
 
         for meta, test in pairs:
@@ -159,7 +152,7 @@ async def _teardown_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}"
-                await cursor.execute(template.format(**test))
+                await cursor.execute(template.format(**(meta | test)))
 
                 template = "DROP ROLE IF EXISTS {user};"
-                await cursor.execute(template.format(**test))
+                await cursor.execute(template.format(**(meta | test)))

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

@@ -18,7 +18,7 @@
     MinosConfigException,
 )
 from tests.utils import (
-    CONFIG_FILE_PATH,
+    BASE_PATH,
 )
 
 
@@ -69,7 +69,8 @@ def _get_saga(self) -> dict[str, Any]:
 class TestConfig(unittest.TestCase):
     def setUp(self) -> None:
         super().setUp()
-        self.config = _Config(CONFIG_FILE_PATH)
+        self.file_path = BASE_PATH / "config" / "v1.yml"
+        self.config = _Config(self.file_path)
 
     def test_is_subclass(self):
         self.assertTrue(issubclass(Config, InjectableMixin))
@@ -78,10 +79,10 @@ def test_get_injectable_name(self):
         self.assertTrue("config", _Config.get_injectable_name())
 
     def test_file_path(self):
-        self.assertEqual(CONFIG_FILE_PATH, self.config.file_path)
+        self.assertEqual(self.file_path, self.config.file_path)
 
     def test_file_path_from_str(self):
-        self.assertEqual(CONFIG_FILE_PATH, _Config(str(CONFIG_FILE_PATH)).file_path)
+        self.assertEqual(self.file_path, _Config(str(self.file_path)).file_path)
 
     def test_file_raises(self):
         with self.assertRaises(MinosConfigException):
@@ -215,7 +216,7 @@ def test_get_saga(self):
         self.assertEqual([call()], mock.call_args_list)
 
     def test_new(self):
-        config = Config(CONFIG_FILE_PATH)
+        config = Config(self.file_path)
         self.assertIsInstance(config, ConfigV1)
 
     def test_new_raises(self):
@@ -224,13 +225,17 @@ def test_new_raises(self):
 
 
 class TestMinosConfig(unittest.TestCase):
+    def setUp(self) -> None:
+        super().setUp()
+        self.file_path = BASE_PATH / "config" / "v1.yml"
+
     def test_is_subclass(self):
         self.assertTrue(issubclass(MinosConfig, Config))
 
     def test_warnings(self):
         with warnings.catch_warnings():
             warnings.simplefilter("ignore", DeprecationWarning)
-            config = MinosConfig(CONFIG_FILE_PATH)
+            config = MinosConfig(self.file_path)
             self.assertIsInstance(config, Config)
 
 

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

@@ -62,7 +62,7 @@ async def test_submit_query(self):
         async with DatabaseMixin() as database:
             await database.submit_query("CREATE TABLE foo (id INT NOT NULL);")
 
-        async with aiopg.connect(**self.repository_db) as connection:
+        async with aiopg.connect(**self.config.get_default_database()) as connection:
             async with connection.cursor() as cursor:
                 await cursor.execute("SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = 'foo');")
                 self.assertTrue((await cursor.fetchone())[0])
@@ -71,7 +71,7 @@ async def test_submit_query_locked(self):
         async with DatabaseMixin() as database:
             await database.submit_query("CREATE TABLE foo (id INT NOT NULL);", lock=1234)
 
-        async with aiopg.connect(**self.repository_db) as connection:
+        async with aiopg.connect(**self.config.get_default_database()) as connection:
             async with connection.cursor() as cursor:
                 await cursor.execute("SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = 'foo');")
                 self.assertTrue((await cursor.fetchone())[0])

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

@@ -22,27 +22,27 @@ def test_base(self):
         self.assertTrue(issubclass(DatabaseLock, Lock))
 
     async def test_wrapped_connection(self):
-        wrapped_connection = aiopg.connect(**self.repository_db)
+        wrapped_connection = aiopg.connect(**self.config.get_default_database())
         lock = DatabaseLock(wrapped_connection, "foo")
         self.assertEqual(wrapped_connection, lock.wrapped_connection)
 
     async def test_key(self):
-        wrapped_connection = aiopg.connect(**self.repository_db)
+        wrapped_connection = aiopg.connect(**self.config.get_default_database())
         lock = DatabaseLock(wrapped_connection, "foo")
         self.assertEqual("foo", lock.key)
 
     async def test_key_raises(self):
-        wrapped_connection = aiopg.connect(**self.repository_db)
+        wrapped_connection = aiopg.connect(**self.config.get_default_database())
         with self.assertRaises(ValueError):
             DatabaseLock(wrapped_connection, [])
 
     async def test_hashed_key(self):
-        wrapped_connection = aiopg.connect(**self.repository_db)
+        wrapped_connection = aiopg.connect(**self.config.get_default_database())
         lock = DatabaseLock(wrapped_connection, "foo")
         self.assertEqual(hash("foo"), lock.hashed_key)
 
     async def test_cursor(self):
-        wrapped_connection = aiopg.connect(**self.repository_db)
+        wrapped_connection = aiopg.connect(**self.config.get_default_database())
         async with DatabaseLock(wrapped_connection, "foo") as lock:
             self.assertIsInstance(lock.cursor, Cursor)
 

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

@@ -59,7 +59,7 @@ def test_from_config(self):
         launcher = EntrypointLauncher.from_config(self.config)
         self.assertIsInstance(launcher, EntrypointLauncher)
         self.assertEqual(self.config, launcher.config)
-        self.assertEqual(12, len(launcher.injections))
+        self.assertEqual(len(self.config.get_injections()), len(launcher.injections))
 
         for injection in launcher.injections.values():
             self.assertIsInstance(injection, InjectableMixin)

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

@@ -19,22 +19,18 @@
 from minos.common import (
     MinosPool,
     Pool,
+    PoolFactory,
     SetupMixin,
 )
+from tests.utils import (
+    CommonTestCase,
+)
 
 
-class _Pool(Pool):
-    def __init__(self):
-        super().__init__()
-        self.create_instance_call_count = 0
-        self.destroy_instance_call_count = 0
-
-    async def _create_instance(self):
-        self.create_instance_call_count += 1
-        return "foo"
-
-    async def _destroy_instance(self, instance: t.Any) -> None:
-        self.destroy_instance_call_count += 1
+class TestPoolFactory(CommonTestCase):
+    def test_constructor(self):
+        factory = PoolFactory.from_config(self.config)
+        self.assertIsInstance(factory, PoolFactory)
 
 
 class TestPool(unittest.IsolatedAsyncioTestCase):
@@ -70,6 +66,20 @@ async def _fn2(p):
         self.assertEqual(1, pool_mock.call_count)
 
 
+class _Pool(Pool):
+    def __init__(self):
+        super().__init__()
+        self.create_instance_call_count = 0
+        self.destroy_instance_call_count = 0
+
+    async def _create_instance(self):
+        self.create_instance_call_count += 1
+        return "foo"
+
+    async def _destroy_instance(self, instance: t.Any) -> None:
+        self.destroy_instance_call_count += 1
+
+
 class TestMinosPool(unittest.IsolatedAsyncioTestCase):
     def test_is_subclass(self):
         self.assertTrue(issubclass(MinosPool, SetupMixin))