cleanup

Author: pcrespov

packages/postgres-database/src/simcore_postgres_database/utils_products.py

@@ -13,7 +13,7 @@
 _GroupID = int
 
 
-async def get_default_product_name(conn: AsyncConnection | SAConnection) -> str:
+async def get_default_product_name(conn: AsyncConnection) -> str:
     """The first row in the table is considered as the default product
 
     :: raises ValueError if undefined
@@ -30,7 +30,7 @@ async def get_default_product_name(conn: AsyncConnection | SAConnection) -> str:
 
 
 async def get_product_group_id(
-    connection: SAConnection, product_name: str
+    connection: AsyncConnection, product_name: str
 ) -> _GroupID | None:
     group_id = await connection.scalar(
         sa.select(products.c.group_id).where(products.c.name == product_name)
@@ -39,7 +39,7 @@ async def get_product_group_id(
 
 
 async def execute_get_or_create_product_group(
-    conn: AsyncConnection, product_name: str
+    conn: AsyncConnection | SAConnection, product_name: str
 ) -> int:
     #
     # NOTE: Separated so it can be used in asyncpg and aiopg environs while both

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

@@ -3,49 +3,51 @@
 # pylint: disable=redefined-outer-name
 # pylint: disable=unused-argument
 
-
 import asyncio
 from collections.abc import Callable
 
 import pytest
 import sqlalchemy as sa
-from aiopg.sa.engine import Engine
 from simcore_postgres_database.models.groups import GroupType, groups
 from simcore_postgres_database.models.products import products
 from simcore_postgres_database.utils_products import (
+    execute_get_or_create_product_group,
     get_default_product_name,
     get_or_create_product_group,
     get_product_group_id,
 )
+from sqlalchemy.ext.asyncio import AsyncEngine
 
 
-async def test_default_product(aiopg_engine: Engine, make_products_table: Callable):
-    async with aiopg_engine.acquire() as conn:
+async def test_default_product(
+    asyncpg_engine: AsyncEngine, make_products_table: Callable
+):
+    async with asyncpg_engine.connect() 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(aiopg_engine: Engine):
-    async with aiopg_engine.acquire() as conn:
+async def test_default_product_undefined(asyncpg_engine: AsyncEngine):
+    async with asyncpg_engine.connect() as conn:
         with pytest.raises(ValueError):
             await get_default_product_name(conn)
 
 
 async def test_get_or_create_group_product(
-    aiopg_engine: Engine, make_products_table: Callable
+    asyncpg_engine: AsyncEngine, make_products_table: Callable
 ):
-    async with aiopg_engine.acquire() as conn:
+    async with asyncpg_engine.connect() as conn:
         await make_products_table(conn)
 
-        async for product_row in await conn.execute(
+        async for product_row in await conn.stream(
             sa.select(products.c.name, products.c.group_id).order_by(
                 products.c.priority
             )
         ):
             # get or create
-            product_group_id = await get_or_create_product_group(
+            product_group_id = await execute_get_or_create_product_group(
                 conn, product_name=product_row.name
             )
 
@@ -57,8 +59,7 @@ async def test_get_or_create_group_product(
             result = await conn.execute(
                 groups.select().where(groups.c.gid == product_group_id)
             )
-            assert result.rowcount == 1
-            product_group = await result.first()
+            product_group = result.one()
 
             # check product's group
             assert product_group.type == GroupType.STANDARD
@@ -68,7 +69,7 @@ async def test_get_or_create_group_product(
             # idempotent
             for _ in range(3):
                 assert (
-                    await get_or_create_product_group(
+                    await execute_get_or_create_product_group(
                         conn, product_name=product_row.name
                     )
                     == product_group_id
@@ -78,7 +79,7 @@ async def test_get_or_create_group_product(
             result = await conn.execute(
                 groups.select().where(groups.c.name == product_row.name)
             )
-            assert result.rowcount == 1
+            assert result.one()
 
             assert product_group_id == await get_product_group_id(
                 conn, product_name=product_row.name
@@ -105,14 +106,14 @@ 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(
-    aiopg_engine: Engine, make_products_table: Callable
+    asyncpg_engine: AsyncEngine, make_products_table: Callable
 ):
-    async with aiopg_engine.acquire() as conn:
+    async with asyncpg_engine.connect() as conn:
         await make_products_table(conn)
 
     async def _auto_create_products_groups():
-        async with aiopg_engine.acquire() as conn:
-            async for product_row in await conn.execute(
+        async with asyncpg_engine.connect() as conn:
+            async for product_row in await conn.stream(
                 sa.select(products.c.name, products.c.group_id).order_by(
                     products.c.priority
                 )