🐛 Fix: rename AutoRechargeStmts to AutoRechargeStatements for consistency and update references across the codebase

Author: pcrespov

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

@@ -7,7 +7,7 @@
 from sqlalchemy.dialects.postgresql import insert as pg_insert
 
 
-class AutoRechargeStmts:
+class AutoRechargeStatements:
     @staticmethod
     def is_valid_payment_method(user_id, wallet_id, payment_method_id) -> sa.sql.Select:
         return sa.select(payments_methods.c.payment_method_id).where(

packages/postgres-database/tests/test_utils_payments_autorecharge.py

@@ -4,75 +4,81 @@
 # pylint: disable=too-many-arguments
 
 import datetime
-from typing import TypeAlias
+from collections.abc import AsyncIterable
 
 import pytest
-import sqlalchemy as sa
-from aiopg.sa.connection import SAConnection
-from aiopg.sa.result import RowProxy
 from faker import Faker
 from pytest_simcore.helpers.faker_factories import random_payment_method, utcnow
+from pytest_simcore.helpers.postgres_tools import insert_and_get_row_lifespan
 from simcore_postgres_database.models.payments_methods import (
     InitPromptAckFlowState,
     payments_methods,
 )
-from simcore_postgres_database.utils_payments_autorecharge import AutoRechargeStmts
+from simcore_postgres_database.utils_payments_autorecharge import AutoRechargeStatements
+from sqlalchemy.engine.row import Row
+from sqlalchemy.ext.asyncio import AsyncConnection, AsyncEngine
 
 #
 # HELPERS
 #
 
 
-async def _get_auto_recharge(connection, wallet_id) -> RowProxy | None:
+async def _get_auto_recharge(connection: AsyncConnection, wallet_id) -> Row | None:
     # has recharge trigger?
-    stmt = AutoRechargeStmts.get_wallet_autorecharge(wallet_id)
+    stmt = AutoRechargeStatements.get_wallet_autorecharge(wallet_id)
     result = await connection.execute(stmt)
-    return await result.first()
+    return result.first()
 
 
 async def _is_valid_payment_method(
-    connection, user_id, wallet_id, payment_method_id
+    connection: AsyncConnection, user_id, wallet_id, payment_method_id
 ) -> bool:
 
-    stmt = AutoRechargeStmts.is_valid_payment_method(
+    stmt = AutoRechargeStatements.is_valid_payment_method(
         user_id, wallet_id, payment_method_id
     )
     primary_payment_method_id = await connection.scalar(stmt)
     return primary_payment_method_id == payment_method_id
 
 
 async def _upsert_autorecharge(
-    connection,
+    connection: AsyncConnection,
     wallet_id,
     enabled,
     primary_payment_method_id,
     top_up_amount_in_usd,
     monthly_limit_in_usd,
-) -> RowProxy:
+) -> Row:
     # using this primary payment-method, create an autorecharge
     # NOTE: requires the entire
-    stmt = AutoRechargeStmts.upsert_wallet_autorecharge(
+    stmt = AutoRechargeStatements.upsert_wallet_autorecharge(
         wallet_id=wallet_id,
         enabled=enabled,
         primary_payment_method_id=primary_payment_method_id,
         top_up_amount_in_usd=top_up_amount_in_usd,
         monthly_limit_in_usd=monthly_limit_in_usd,
     )
-    row = await (await connection.execute(stmt)).first()
-    assert row
-    return row
+    result = await connection.execute(stmt)
+    return result.one()
 
 
-async def _update_autorecharge(connection, wallet_id, **settings) -> int | None:
-    stmt = AutoRechargeStmts.update_wallet_autorecharge(wallet_id, **settings)
+async def _update_autorecharge(
+    connection: AsyncConnection, wallet_id, **settings
+) -> int | None:
+    stmt = AutoRechargeStatements.update_wallet_autorecharge(wallet_id, **settings)
     return await connection.scalar(stmt)
 
 
-PaymentMethodRow: TypeAlias = RowProxy
+class PaymentMethodRow(dict):
+    # Convert dict to Row-like object for compatibility
+    def __getattr__(self, key):
+        return self[key]
 
 
 @pytest.fixture
-async def payment_method(connection: SAConnection, faker: Faker) -> PaymentMethodRow:
+async def payment_method(
+    asyncpg_engine: AsyncEngine, faker: Faker
+) -> AsyncIterable[PaymentMethodRow]:
     payment_method_id = faker.uuid4().upper()
 
     raw_payment_method = random_payment_method(
@@ -81,57 +87,61 @@ async def payment_method(connection: SAConnection, faker: Faker) -> PaymentMetho
         completed_at=utcnow() + datetime.timedelta(seconds=1),
         state=InitPromptAckFlowState.SUCCESS,
     )
-    result = await connection.execute(
-        payments_methods.insert()
-        .values(**raw_payment_method)
-        .returning(sa.literal_column("*"))
-    )
-    row = await result.first()
-    assert row
-    assert row.payment_method_id == payment_method_id
-    wallet_id = row.wallet_id
-    user_id = row.user_id
-
-    assert await _is_valid_payment_method(
-        connection, user_id, wallet_id, payment_method_id
-    )
-    return row
+
+    # pylint: disable=contextmanager-generator-missing-cleanup
+    async with insert_and_get_row_lifespan(
+        asyncpg_engine,
+        table=payments_methods,
+        values=raw_payment_method,
+        pk_col=payments_methods.c.payment_method_id,
+        pk_value=payment_method_id,
+    ) as row_data:
+        wallet_id = row_data["wallet_id"]
+        user_id = row_data["user_id"]
+
+        async with asyncpg_engine.connect() as connection:
+            assert await _is_valid_payment_method(
+                connection, user_id, wallet_id, payment_method_id
+            )
+
+        yield PaymentMethodRow(row_data)
 
 
 async def test_payments_automation_workflow(
-    connection: SAConnection, payment_method: PaymentMethodRow
+    asyncpg_engine: AsyncEngine, payment_method: PaymentMethodRow
 ):
     payment_method_id = payment_method.payment_method_id
     wallet_id = payment_method.wallet_id
 
-    # get
-    auto_recharge = await _get_auto_recharge(connection, wallet_id)
-    assert auto_recharge is None
-
-    # new
-    await _upsert_autorecharge(
-        connection,
-        wallet_id,
-        enabled=True,
-        primary_payment_method_id=payment_method_id,
-        top_up_amount_in_usd=100,
-        monthly_limit_in_usd=None,
-    )
-
-    auto_recharge = await _get_auto_recharge(connection, wallet_id)
-    assert auto_recharge is not None
-    assert auto_recharge.primary_payment_method_id == payment_method_id
-    assert auto_recharge.enabled is True
-
-    # upsert: deactivate countdown
-    auto_recharge = await _upsert_autorecharge(
-        connection,
-        wallet_id,
-        enabled=True,
-        primary_payment_method_id=payment_method_id,
-        top_up_amount_in_usd=100,
-        monthly_limit_in_usd=10000,  # <----
-    )
-    assert auto_recharge.monthly_limit_in_usd == 10000
-
-    await _update_autorecharge(connection, wallet_id, monthly_limit_in_usd=None)
+    async with asyncpg_engine.begin() as connection:
+        # get
+        auto_recharge = await _get_auto_recharge(connection, wallet_id)
+        assert auto_recharge is None
+
+        # new
+        await _upsert_autorecharge(
+            connection,
+            wallet_id,
+            enabled=True,
+            primary_payment_method_id=payment_method_id,
+            top_up_amount_in_usd=100,
+            monthly_limit_in_usd=None,
+        )
+
+        auto_recharge = await _get_auto_recharge(connection, wallet_id)
+        assert auto_recharge is not None
+        assert auto_recharge.primary_payment_method_id == payment_method_id
+        assert auto_recharge.enabled is True
+
+        # upsert: deactivate countdown
+        auto_recharge = await _upsert_autorecharge(
+            connection,
+            wallet_id,
+            enabled=True,
+            primary_payment_method_id=payment_method_id,
+            top_up_amount_in_usd=100,
+            monthly_limit_in_usd=10000,  # <----
+        )
+        assert auto_recharge.monthly_limit_in_usd == 10000
+
+        await _update_autorecharge(connection, wallet_id, monthly_limit_in_usd=None)

services/payments/src/simcore_service_payments/db/auto_recharge_repo.py

@@ -6,7 +6,7 @@
 from models_library.users import UserID
 from models_library.wallets import WalletID
 from pydantic import BaseModel, ConfigDict, PositiveInt
-from simcore_postgres_database.utils_payments_autorecharge import AutoRechargeStmts
+from simcore_postgres_database.utils_payments_autorecharge import AutoRechargeStatements
 
 from .base import BaseRepository
 
@@ -33,7 +33,7 @@ async def get_wallet_autorecharge(
         """
 
         async with self.db_engine.begin() as conn:
-            stmt = AutoRechargeStmts.get_wallet_autorecharge(wallet_id)
+            stmt = AutoRechargeStatements.get_wallet_autorecharge(wallet_id)
             result = await conn.execute(stmt)
             row = result.first()
             return PaymentsAutorechargeDB.model_validate(row) if row else None
@@ -50,7 +50,7 @@ async def replace_wallet_autorecharge(
 
         """
         async with self.db_engine.begin() as conn:
-            stmt = AutoRechargeStmts.is_valid_payment_method(
+            stmt = AutoRechargeStatements.is_valid_payment_method(
                 user_id=user_id,
                 wallet_id=new.wallet_id,
                 payment_method_id=new.primary_payment_method_id,
@@ -61,7 +61,7 @@ async def replace_wallet_autorecharge(
                     payment_method_id=new.primary_payment_method_id
                 )
 
-            stmt = AutoRechargeStmts.upsert_wallet_autorecharge(
+            stmt = AutoRechargeStatements.upsert_wallet_autorecharge(
                 wallet_id=wallet_id,
                 enabled=new.enabled,
                 primary_payment_method_id=new.primary_payment_method_id,

services/web/server/src/simcore_service_webserver/payments/_autorecharge_db.py

@@ -7,7 +7,7 @@
 from models_library.users import UserID
 from models_library.wallets import WalletID
 from pydantic import BaseModel, ConfigDict, PositiveInt
-from simcore_postgres_database.utils_payments_autorecharge import AutoRechargeStmts
+from simcore_postgres_database.utils_payments_autorecharge import AutoRechargeStatements
 from simcore_postgres_database.utils_repos import (
     pass_or_acquire_connection,
     transaction_context,
@@ -39,7 +39,7 @@ async def get_wallet_autorecharge(
     wallet_id: WalletID,
 ) -> PaymentsAutorechargeGetDB | None:
     async with pass_or_acquire_connection(get_asyncpg_engine(app), connection) as conn:
-        stmt = AutoRechargeStmts.get_wallet_autorecharge(wallet_id)
+        stmt = AutoRechargeStatements.get_wallet_autorecharge(wallet_id)
         result = await conn.execute(stmt)
         row = result.one_or_none()
         return PaymentsAutorechargeGetDB.model_validate(row) if row else None
@@ -59,7 +59,7 @@ async def replace_wallet_autorecharge(
 
     """
     async with transaction_context(get_asyncpg_engine(app), connection) as conn:
-        stmt = AutoRechargeStmts.is_valid_payment_method(
+        stmt = AutoRechargeStatements.is_valid_payment_method(
             user_id=user_id,
             wallet_id=new.wallet_id,
             payment_method_id=new.primary_payment_method_id,
@@ -70,7 +70,7 @@ async def replace_wallet_autorecharge(
                 payment_method_id=new.primary_payment_method_id
             )
 
-        stmt = AutoRechargeStmts.upsert_wallet_autorecharge(
+        stmt = AutoRechargeStatements.upsert_wallet_autorecharge(
             wallet_id=wallet_id,
             enabled=new.enabled,
             primary_payment_method_id=new.primary_payment_method_id,