fixed usage

Author: sanderegg

packages/postgres-database/tests/conftest.py

@@ -339,8 +339,8 @@ async def _creator(product_name: str) -> Row:
             )
             assert result
             row = result.one()
-            created_product_names.add(row.name)
-            return row
+        created_product_names.add(row.name)
+        return row
 
     yield _creator
 

packages/postgres-database/tests/test_utils_user_preferences.py

@@ -1,7 +1,7 @@
 # pylint: disable=inconsistent-return-statements
 # pylint: disable=redefined-outer-name
 
-from collections.abc import AsyncIterator, Awaitable, Callable
+from collections.abc import Awaitable, Callable
 from typing import Any
 
 import pytest
@@ -14,7 +14,7 @@
     UserServicesUserPreferencesRepo,
 )
 from sqlalchemy.engine.row import Row
-from sqlalchemy.ext.asyncio import AsyncConnection, AsyncEngine
+from sqlalchemy.ext.asyncio import AsyncEngine
 
 
 @pytest.fixture
@@ -40,54 +40,49 @@ def preference_repo(request: pytest.FixtureRequest) -> type[BasePreferencesRepo]
     return request.param
 
 
-@pytest.fixture
-async def connection(
-    asyncpg_engine: AsyncEngine,
-) -> AsyncIterator[AsyncConnection]:
-    async with asyncpg_engine.begin() as connection:
-        yield connection
-
-
 async def _assert_save_get_preference(
-    connection: AsyncConnection,
+    asyncpg_engine: AsyncEngine,
     preference_repo: type[BasePreferencesRepo],
     *,
     user_id: int,
     preference_name: str,
     product_name: str,
     payload: Any,
 ) -> None:
-    await preference_repo.save(
-        connection,
-        user_id=user_id,
-        preference_name=preference_name,
-        product_name=product_name,
-        payload=payload,
-    )
-    get_res_2: Any | None = await preference_repo.load(
-        connection,
-        user_id=user_id,
-        preference_name=preference_name,
-        product_name=product_name,
-    )
+    async with asyncpg_engine.begin() as connection:
+        await preference_repo.save(
+            connection,
+            user_id=user_id,
+            preference_name=preference_name,
+            product_name=product_name,
+            payload=payload,
+        )
+    async with asyncpg_engine.connect() as connection:
+        get_res_2: Any | None = await preference_repo.load(
+            connection,
+            user_id=user_id,
+            preference_name=preference_name,
+            product_name=product_name,
+        )
     assert get_res_2 is not None
     assert get_res_2 == payload
 
 
 async def _assert_preference_not_saved(
-    connection: AsyncConnection,
+    asyncpg_engine: AsyncEngine,
     preference_repo: type[BasePreferencesRepo],
     *,
     user_id: int,
     preference_name: str,
     product_name: str,
 ) -> None:
-    not_found: Any | None = await preference_repo.load(
-        connection,
-        user_id=user_id,
-        preference_name=preference_name,
-        product_name=product_name,
-    )
+    async with asyncpg_engine.connect() as connection:
+        not_found: Any | None = await preference_repo.load(
+            connection,
+            user_id=user_id,
+            preference_name=preference_name,
+            product_name=product_name,
+        )
     assert not_found is None
 
 
@@ -102,26 +97,27 @@ def _get_random_payload(
     pytest.fail(f"Did not define a casa for {preference_repo=}. Please add one.")
 
 
-async def _get_user_id(connection: AsyncConnection, faker: Faker) -> int:
+async def _create_user_id(asyncpg_engine: AsyncEngine, faker: Faker) -> int:
     data = random_user(role=faker.random_element(elements=UserRole))
-    user_id = await connection.scalar(
-        users.insert().values(**data).returning(users.c.id)
-    )
+    async with asyncpg_engine.begin() as connection:
+        user_id = await connection.scalar(
+            users.insert().values(**data).returning(users.c.id)
+        )
     assert user_id
     return user_id
 
 
 async def test_user_preference_repo_workflow(
-    connection: AsyncConnection,
+    asyncpg_engine: AsyncEngine,
     preference_repo: type[BasePreferencesRepo],
     preference_one: str,
     product_name: str,
     faker: Faker,
 ):
-    user_id = await _get_user_id(connection, faker)
+    user_id = await _create_user_id(asyncpg_engine, faker)
     # preference is not saved
     await _assert_preference_not_saved(
-        connection,
+        asyncpg_engine,
         preference_repo,
         user_id=user_id,
         preference_name=preference_one,
@@ -134,7 +130,7 @@ async def test_user_preference_repo_workflow(
 
     # store the preference for the first time
     await _assert_save_get_preference(
-        connection,
+        asyncpg_engine,
         preference_repo,
         user_id=user_id,
         preference_name=preference_one,
@@ -144,7 +140,7 @@ async def test_user_preference_repo_workflow(
 
     # updating the preference still works
     await _assert_save_get_preference(
-        connection,
+        asyncpg_engine,
         preference_repo,
         user_id=user_id,
         preference_name=preference_one,
@@ -154,29 +150,29 @@ async def test_user_preference_repo_workflow(
 
 
 async def test__same_preference_name_product_name__different_users(
-    connection: AsyncConnection,
+    asyncpg_engine: AsyncEngine,
     preference_repo: type[BasePreferencesRepo],
     preference_one: str,
     product_name: str,
     faker: Faker,
 ):
-    user_id_1 = await _get_user_id(connection, faker)
-    user_id_2 = await _get_user_id(connection, faker)
+    user_id_1 = await _create_user_id(asyncpg_engine, faker)
+    user_id_2 = await _create_user_id(asyncpg_engine, faker)
 
     payload_1 = _get_random_payload(faker, preference_repo)
     payload_2 = _get_random_payload(faker, preference_repo)
     assert payload_1 != payload_2
 
     # save preference for first user
     await _assert_preference_not_saved(
-        connection,
+        asyncpg_engine,
         preference_repo,
         user_id=user_id_1,
         preference_name=preference_one,
         product_name=product_name,
     )
     await _assert_save_get_preference(
-        connection,
+        asyncpg_engine,
         preference_repo,
         user_id=user_id_1,
         preference_name=preference_one,
@@ -186,14 +182,14 @@ async def test__same_preference_name_product_name__different_users(
 
     # save preference for second user
     await _assert_preference_not_saved(
-        connection,
+        asyncpg_engine,
         preference_repo,
         user_id=user_id_2,
         preference_name=preference_one,
         product_name=product_name,
     )
     await _assert_save_get_preference(
-        connection,
+        asyncpg_engine,
         preference_repo,
         user_id=user_id_2,
         preference_name=preference_one,
@@ -203,7 +199,7 @@ async def test__same_preference_name_product_name__different_users(
 
 
 async def test__same_user_preference_name__different_product_name(
-    connection: AsyncConnection,
+    asyncpg_engine: AsyncEngine,
     create_fake_product: Callable[[str], Awaitable[Row]],
     preference_repo: type[BasePreferencesRepo],
     preference_one: str,
@@ -212,22 +208,22 @@ async def test__same_user_preference_name__different_product_name(
     product_1 = (await create_fake_product("fake-product-1"))[0]
     product_2 = (await create_fake_product("fake-product-2"))[0]
 
-    user_id = await _get_user_id(connection, faker)
+    user_id = await _create_user_id(asyncpg_engine, faker)
 
     payload_1 = _get_random_payload(faker, preference_repo)
     payload_2 = _get_random_payload(faker, preference_repo)
     assert payload_1 != payload_2
 
     # save for first product_name
     await _assert_preference_not_saved(
-        connection,
+        asyncpg_engine,
         preference_repo,
         user_id=user_id,
         preference_name=preference_one,
         product_name=product_1,
     )
     await _assert_save_get_preference(
-        connection,
+        asyncpg_engine,
         preference_repo,
         user_id=user_id,
         preference_name=preference_one,
@@ -237,14 +233,14 @@ async def test__same_user_preference_name__different_product_name(
 
     # save for second product_name
     await _assert_preference_not_saved(
-        connection,
+        asyncpg_engine,
         preference_repo,
         user_id=user_id,
         preference_name=preference_one,
         product_name=product_2,
     )
     await _assert_save_get_preference(
-        connection,
+        asyncpg_engine,
         preference_repo,
         user_id=user_id,
         preference_name=preference_one,
@@ -254,29 +250,29 @@ async def test__same_user_preference_name__different_product_name(
 
 
 async def test__same_product_name_user__different_preference_name(
-    connection: AsyncConnection,
+    asyncpg_engine: AsyncEngine,
     preference_repo: type[BasePreferencesRepo],
     preference_one: str,
     preference_two: str,
     product_name: str,
     faker: Faker,
 ):
-    user_id = await _get_user_id(connection, faker)
+    user_id = await _create_user_id(asyncpg_engine, faker)
 
     payload_1 = _get_random_payload(faker, preference_repo)
     payload_2 = _get_random_payload(faker, preference_repo)
     assert payload_1 != payload_2
 
     # save first preference
     await _assert_preference_not_saved(
-        connection,
+        asyncpg_engine,
         preference_repo,
         user_id=user_id,
         preference_name=preference_one,
         product_name=product_name,
     )
     await _assert_save_get_preference(
-        connection,
+        asyncpg_engine,
         preference_repo,
         user_id=user_id,
         preference_name=preference_one,
@@ -286,14 +282,14 @@ async def test__same_product_name_user__different_preference_name(
 
     # save second preference
     await _assert_preference_not_saved(
-        connection,
+        asyncpg_engine,
         preference_repo,
         user_id=user_id,
         preference_name=preference_two,
         product_name=product_name,
     )
     await _assert_save_get_preference(
-        connection,
+        asyncpg_engine,
         preference_repo,
         user_id=user_id,
         preference_name=preference_two,