renames aiopg_engine

Author: pcrespov

packages/postgres-database/tests/conftest.py

@@ -166,26 +166,26 @@ def pg_sa_engine(
 
 
 @pytest.fixture
-async def pg_engine(
+async def aiopg_engine(
     pg_sa_engine: sa.engine.Engine, make_engine: Callable
 ) -> AsyncIterator[Engine]:
     """
     Return an aiopg.sa engine connected to a responsive and migrated pg database
     """
-    async_engine = await make_engine(is_async=True)
+    aiopg_sa_engine = await make_engine(is_async=True)
 
-    yield async_engine
+    yield aiopg_sa_engine
 
     # closes async-engine connections and terminates
-    async_engine.close()
-    await async_engine.wait_closed()
-    async_engine.terminate()
+    aiopg_sa_engine.close()
+    await aiopg_sa_engine.wait_closed()
+    aiopg_sa_engine.terminate()
 
 
 @pytest.fixture
-async def connection(pg_engine: Engine) -> AsyncIterator[SAConnection]:
+async def connection(aiopg_engine: Engine) -> AsyncIterator[SAConnection]:
     """Returns an aiopg.sa connection from an engine to a fully furnished and ready pg database"""
-    async with pg_engine.acquire() as _conn:
+    async with aiopg_engine.acquire() as _conn:
         yield _conn
 
 
@@ -264,7 +264,7 @@ async def _creator(conn, group: RowProxy | None = None, **overrides) -> RowProxy
 
 @pytest.fixture
 async def create_fake_cluster(
-    pg_engine: Engine, faker: Faker
+    aiopg_engine: Engine, faker: Faker
 ) -> AsyncIterator[Callable[..., Awaitable[int]]]:
     cluster_ids = []
     assert cluster_to_groups is not None
@@ -278,7 +278,7 @@ async def _creator(**overrides) -> int:
             "authentication": faker.pydict(value_types=[str]),
         }
         insert_values.update(overrides)
-        async with pg_engine.acquire() as conn:
+        async with aiopg_engine.acquire() as conn:
             cluster_id = await conn.scalar(
                 clusters.insert().values(**insert_values).returning(clusters.c.id)
             )
@@ -289,13 +289,13 @@ async def _creator(**overrides) -> int:
     yield _creator
 
     # cleanup
-    async with pg_engine.acquire() as conn:
+    async with aiopg_engine.acquire() as conn:
         await conn.execute(clusters.delete().where(clusters.c.id.in_(cluster_ids)))
 
 
 @pytest.fixture
 async def create_fake_project(
-    pg_engine: Engine,
+    aiopg_engine: Engine,
 ) -> AsyncIterator[Callable[..., Awaitable[RowProxy]]]:
     created_project_uuids = []
 
@@ -312,7 +312,7 @@ async def _creator(conn, user: RowProxy, **overrides) -> RowProxy:
 
     yield _creator
 
-    async with pg_engine.acquire() as conn:
+    async with aiopg_engine.acquire() as conn:
         await conn.execute(
             projects.delete().where(projects.c.uuid.in_(created_project_uuids))
         )

packages/postgres-database/tests/products/test_models_products.py

@@ -26,14 +26,14 @@
 
 
 async def test_load_products(
-    pg_engine: Engine, make_products_table: Callable, products_regex: dict
+    aiopg_engine: Engine, make_products_table: Callable, products_regex: dict
 ):
     exclude = {
         products.c.created,
         products.c.modified,
     }
 
-    async with pg_engine.acquire() as conn:
+    async with aiopg_engine.acquire() as conn:
         await make_products_table(conn)
 
         stmt = sa.select(*[c for c in products.columns if c not in exclude])
@@ -49,14 +49,14 @@ async def test_load_products(
 
 
 async def test_jinja2_templates_table(
-    pg_engine: Engine, osparc_simcore_services_dir: Path
+    aiopg_engine: Engine, osparc_simcore_services_dir: Path
 ):
     templates_common_dir = (
         osparc_simcore_services_dir
         / "web/server/src/simcore_service_webserver/templates/common"
     )
 
-    async with pg_engine.acquire() as conn:
+    async with aiopg_engine.acquire() as conn:
         templates = []
         # templates table
         for p in templates_common_dir.glob("*.jinja2"):
@@ -135,7 +135,7 @@ async def test_jinja2_templates_table(
 
 
 async def test_insert_select_product(
-    pg_engine: Engine,
+    aiopg_engine: Engine,
 ):
     osparc_product = {
         "name": "osparc",
@@ -174,7 +174,7 @@ async def test_insert_select_product(
 
     print(json.dumps(osparc_product))
 
-    async with pg_engine.acquire() as conn:
+    async with aiopg_engine.acquire() as conn:
         # writes
         stmt = (
             pg_insert(products)

packages/postgres-database/tests/products/test_utils_products.py

@@ -19,24 +19,24 @@
 )
 
 
-async def test_default_product(pg_engine: Engine, make_products_table: Callable):
-    async with pg_engine.acquire() as conn:
+async def test_default_product(aiopg_engine: Engine, make_products_table: Callable):
+    async with aiopg_engine.acquire() as conn:
         await make_products_table(conn)
         default_product = await get_default_product_name(conn)
         assert default_product == "s4l"
 
 
 @pytest.mark.parametrize("pg_sa_engine", ["sqlModels"], indirect=True)
-async def test_default_product_undefined(pg_engine: Engine):
-    async with pg_engine.acquire() as conn:
+async def test_default_product_undefined(aiopg_engine: Engine):
+    async with aiopg_engine.acquire() as conn:
         with pytest.raises(ValueError):
             await get_default_product_name(conn)
 
 
 async def test_get_or_create_group_product(
-    pg_engine: Engine, make_products_table: Callable
+    aiopg_engine: Engine, make_products_table: Callable
 ):
-    async with pg_engine.acquire() as conn:
+    async with aiopg_engine.acquire() as conn:
         await make_products_table(conn)
 
         async for product_row in await conn.execute(
@@ -105,13 +105,13 @@ async def test_get_or_create_group_product(
     reason="Not relevant. Will review in https://github.com/ITISFoundation/osparc-simcore/issues/3754"
 )
 async def test_get_or_create_group_product_concurrent(
-    pg_engine: Engine, make_products_table: Callable
+    aiopg_engine: Engine, make_products_table: Callable
 ):
-    async with pg_engine.acquire() as conn:
+    async with aiopg_engine.acquire() as conn:
         await make_products_table(conn)
 
     async def _auto_create_products_groups():
-        async with pg_engine.acquire() as conn:
+        async with aiopg_engine.acquire() as conn:
             async for product_row in await conn.execute(
                 sa.select(products.c.name, products.c.group_id).order_by(
                     products.c.priority

packages/postgres-database/tests/projects/conftest.py

@@ -16,10 +16,10 @@
 
 
 @pytest.fixture
-async def user(pg_engine: Engine) -> RowProxy:
+async def user(aiopg_engine: Engine) -> RowProxy:
     _USERNAME = f"{__name__}.me"
     # some user
-    async with pg_engine.acquire() as conn:
+    async with aiopg_engine.acquire() as conn:
         result: ResultProxy | None = await conn.execute(
             users.insert().values(**random_user(name=_USERNAME)).returning(users)
         )
@@ -32,10 +32,10 @@ async def user(pg_engine: Engine) -> RowProxy:
 
 
 @pytest.fixture
-async def project(pg_engine: Engine, user: RowProxy) -> RowProxy:
+async def project(aiopg_engine: Engine, user: RowProxy) -> RowProxy:
     _PARENT_PROJECT_NAME = f"{__name__}.parent"
     # a user's project
-    async with pg_engine.acquire() as conn:
+    async with aiopg_engine.acquire() as conn:
         result: ResultProxy | None = await conn.execute(
             projects.insert()
             .values(**random_project(prj_owner=user.id, name=_PARENT_PROJECT_NAME))
@@ -50,6 +50,6 @@ async def project(pg_engine: Engine, user: RowProxy) -> RowProxy:
 
 
 @pytest.fixture
-async def conn(pg_engine: Engine) -> AsyncIterable[SAConnection]:
-    async with pg_engine.acquire() as conn:
+async def conn(aiopg_engine: Engine) -> AsyncIterable[SAConnection]:
+    async with aiopg_engine.acquire() as conn:
         yield conn

packages/postgres-database/tests/test_classifiers.py

@@ -38,10 +38,10 @@ def classifiers_bundle(web_client_resource_folder: Path) -> dict:
 
 
 async def test_operations_on_group_classifiers(
-    pg_engine: Engine, classifiers_bundle: dict
+    aiopg_engine: Engine, classifiers_bundle: dict
 ):
     # NOTE: mostly for TDD
-    async with pg_engine.acquire() as conn:
+    async with aiopg_engine.acquire() as conn:
         # creates a group
         stmt = (
             groups.insert()

packages/postgres-database/tests/test_clusters.py

@@ -16,23 +16,23 @@
 
 
 @pytest.fixture
-async def user_id(pg_engine: Engine) -> AsyncIterable[int]:
-    async with pg_engine.acquire() as conn:
+async def user_id(aiopg_engine: Engine) -> AsyncIterable[int]:
+    async with aiopg_engine.acquire() as conn:
         # a 'me' user
         uid = await conn.scalar(
             users.insert().values(**(random_user())).returning(users.c.id)
         )
     assert uid is not None
     yield uid
     # cleanup
-    async with pg_engine.acquire() as conn:
+    async with aiopg_engine.acquire() as conn:
         # a 'me' user
         uid = await conn.execute(users.delete().where(users.c.id == uid))
 
 
 @pytest.fixture
-async def user_group_id(pg_engine: Engine, user_id: int) -> int:
-    async with pg_engine.acquire() as conn:
+async def user_group_id(aiopg_engine: Engine, user_id: int) -> int:
+    async with aiopg_engine.acquire() as conn:
         primary_gid = await conn.scalar(
             sa.select(users.c.primary_gid).where(users.c.id == user_id)
         )
@@ -64,34 +64,34 @@ async def test_can_create_cluster_with_owner(
 
 
 async def test_cannot_remove_owner_that_owns_cluster(
-    pg_engine: Engine,
+    aiopg_engine: Engine,
     user_id: int,
     user_group_id: int,
     create_fake_cluster: Callable[..., Awaitable[int]],
 ):
     cluster_id = await create_fake_cluster(owner=user_group_id)
     # now try removing the user
-    async with pg_engine.acquire() as conn:
+    async with aiopg_engine.acquire() as conn:
         with pytest.raises(ForeignKeyViolation):
             await conn.execute(users.delete().where(users.c.id == user_id))
 
     # now remove the cluster
-    async with pg_engine.acquire() as conn:
+    async with aiopg_engine.acquire() as conn:
         await conn.execute(clusters.delete().where(clusters.c.id == cluster_id))
 
     # removing the user should work now
-    async with pg_engine.acquire() as conn:
+    async with aiopg_engine.acquire() as conn:
         await conn.execute(users.delete().where(users.c.id == user_id))
 
 
 async def test_cluster_owner_has_all_rights(
-    pg_engine: Engine,
+    aiopg_engine: Engine,
     user_group_id: int,
     create_fake_cluster: Callable[..., Awaitable[int]],
 ):
     cluster_id = await create_fake_cluster(owner=user_group_id)
 
-    async with pg_engine.acquire() as conn:
+    async with aiopg_engine.acquire() as conn:
         result: ResultProxy = await conn.execute(
             cluster_to_groups.select().where(
                 cluster_to_groups.c.cluster_id == cluster_id

packages/postgres-database/tests/test_comp_tasks.py

@@ -19,8 +19,8 @@
 
 
 @pytest.fixture()
-async def db_connection(pg_engine: Engine) -> SAConnection:
-    async with pg_engine.acquire() as conn:
+async def db_connection(aiopg_engine: Engine) -> SAConnection:
+    async with aiopg_engine.acquire() as conn:
         yield conn
 
 

packages/postgres-database/tests/test_delete_projects_and_users.py

@@ -15,8 +15,8 @@
 
 
 @pytest.fixture
-async def engine(pg_engine: Engine):
-    async with pg_engine.acquire() as conn:
+async def engine(aiopg_engine: Engine):
+    async with aiopg_engine.acquire() as conn:
         await conn.execute(users.insert().values(**random_user(name="A")))
         await conn.execute(users.insert().values(**random_user()))
         await conn.execute(users.insert().values(**random_user()))
@@ -27,7 +27,7 @@ async def engine(pg_engine: Engine):
         with pytest.raises(ForeignKeyViolation):
             await conn.execute(projects.insert().values(**random_project(prj_owner=4)))
 
-    return pg_engine
+    return aiopg_engine
 
 
 @pytest.mark.skip(reason="sandbox for dev purposes")

packages/postgres-database/tests/test_services_consume_filetypes.py

@@ -59,9 +59,9 @@ async def _make(connection: SAConnection):
 
 @pytest.fixture
 async def connection(
-    pg_engine: sa.engine.Engine, connection: SAConnection, make_table: Callable
+    aiopg_engine: sa.engine.Engine, connection: SAConnection, make_table: Callable
 ):
-    assert pg_engine
+    assert aiopg_engine
     # NOTE: do not remove th pg_engine, or the test will fail as pytest
     # cannot set the parameters in the fixture
 

packages/postgres-database/tests/test_utils_aiopg_orm.py

@@ -16,12 +16,12 @@
 
 
 @pytest.fixture
-async def fake_scicrunch_ids(pg_engine: Engine) -> list[str]:
+async def fake_scicrunch_ids(aiopg_engine: Engine) -> list[str]:
     row1 = {"rrid": "RRID:foo", "name": "foo", "description": "fooing"}
     row2 = {"rrid": "RRID:bar", "name": "bar", "description": "barring"}
 
     row_ids = []
-    async with pg_engine.acquire() as conn:
+    async with aiopg_engine.acquire() as conn:
         for row in (row1, row2):
             row_id = await conn.scalar(
                 scicrunch_resources.insert()
@@ -35,7 +35,7 @@ async def fake_scicrunch_ids(pg_engine: Engine) -> list[str]:
 
 
 @pytest.fixture()
-async def scicrunch_orm(pg_engine: Engine) -> Iterator[BaseOrm[str]]:
+async def scicrunch_orm(aiopg_engine: Engine) -> Iterator[BaseOrm[str]]:
     # This is a table without dependencies and therefore easy to use as fixture
     class ScicrunchOrm(BaseOrm[str]):
         def __init__(self, connection: SAConnection):
@@ -46,7 +46,7 @@ def __init__(self, connection: SAConnection):
                 writeonce={"rrid"},
             )
 
-    async with pg_engine.acquire() as conn:
+    async with aiopg_engine.acquire() as conn:
         orm_obj = ScicrunchOrm(conn)
         yield orm_obj