constant

Author: pcrespov

packages/postgres-database/tests/conftest.py

@@ -81,19 +81,7 @@ def sync_engine(postgres_service: str) -> Iterable[sqlalchemy.engine.Engine]:
 
 
 @pytest.fixture
-def make_engine(
-    postgres_service: str,
-) -> Callable[[bool], Awaitable[Engine] | sqlalchemy.engine.Engine]:
-    dsn = postgres_service
-
-    def _make(is_async=True) -> Awaitable[Engine] | sqlalchemy.engine.Engine:
-        return aiopg.sa.create_engine(dsn) if is_async else sa.create_engine(dsn)
-
-    return _make
-
-
-@pytest.fixture
-def make_asyncpg_engine(postgres_service: str) -> Callable[[bool], AsyncEngine]:
+def _make_asyncpg_engine(postgres_service: str) -> Callable[[bool], AsyncEngine]:
     # NOTE: users is responsible of `await engine.dispose()`
     dsn = postgres_service.replace("postgresql://", "postgresql+asyncpg://")
     minsize = 1
@@ -178,13 +166,15 @@ def pg_sa_engine(
 
 @pytest.fixture
 async def aiopg_engine(
-    pg_sa_engine: sqlalchemy.engine.Engine, make_engine: Callable
+    pg_sa_engine: sqlalchemy.engine.Engine,
+    postgres_service: str,
 ) -> AsyncIterator[Engine]:
     """
     Return an aiopg.sa engine connected to a responsive and migrated pg database
     """
-
-    aiopg_sa_engine = await make_engine(is_async=True)
+    # first start sync
+    assert pg_sa_engine.url.database
+    assert postgres_service.endswith(pg_sa_engine.url.database)
 
     warnings.warn(
         "The 'aiopg_engine' is deprecated since we are replacing `aiopg` library by `sqlalchemy.ext.asyncio`."
@@ -194,12 +184,8 @@ async def aiopg_engine(
         stacklevel=2,
     )
 
-    yield aiopg_sa_engine
-
-    # closes async-engine connections and terminates
-    aiopg_sa_engine.close()
-    await aiopg_sa_engine.wait_closed()
-    aiopg_sa_engine.terminate()
+    async with aiopg.sa.create_engine(dsn=postgres_service) as aiopg_sa_engine:
+        yield aiopg_sa_engine
 
 
 @pytest.fixture
@@ -213,14 +199,14 @@ async def connection(aiopg_engine: Engine) -> AsyncIterator[SAConnection]:
 async def asyncpg_engine(  # <-- WE SHOULD USE THIS ONE
     is_pdb_enabled: bool,
     pg_sa_engine: sqlalchemy.engine.Engine,
-    make_asyncpg_engine: Callable[[bool], AsyncEngine],
+    _make_asyncpg_engine: Callable[[bool], AsyncEngine],
 ) -> AsyncIterator[AsyncEngine]:
 
     assert (
         pg_sa_engine
     ), "Ensures pg db up, responsive, init (w/ tables) and/or migrated"
 
-    _apg_engine = make_asyncpg_engine(is_pdb_enabled)
+    _apg_engine = _make_asyncpg_engine(is_pdb_enabled)
 
     yield _apg_engine
 
@@ -233,9 +219,7 @@ async def asyncpg_engine(  # <-- WE SHOULD USE THIS ONE
 
 
 @pytest.fixture
-def create_fake_group(
-    make_engine: Callable[..., Awaitable[Engine] | sqlalchemy.engine.Engine]
-) -> Iterator[Callable]:
+def create_fake_group(sync_engine: sqlalchemy.engine.Engine) -> Iterator[Callable]:
     """factory to create standard group"""
     created_ids = []
 
@@ -254,16 +238,13 @@ async def _creator(conn: SAConnection, **overrides) -> RowProxy:
 
     yield _creator
 
-    sync_engine = make_engine(is_async=False)
     assert isinstance(sync_engine, sqlalchemy.engine.Engine)
     with sync_engine.begin() as conn:
         conn.execute(sa.delete(groups).where(groups.c.gid.in_(created_ids)))
 
 
 @pytest.fixture
-def create_fake_user(
-    make_engine: Callable[..., Awaitable[Engine] | sqlalchemy.engine.Engine]
-) -> Iterator[Callable]:
+def create_fake_user(sync_engine: sqlalchemy.engine.Engine) -> Iterator[Callable]:
     """factory to create a user w/ or w/o a standard group"""
 
     created_ids = []
@@ -294,7 +275,6 @@ async def _creator(conn, group: RowProxy | None = None, **overrides) -> RowProxy
 
     yield _creator
 
-    sync_engine = make_engine(is_async=False)
     assert isinstance(sync_engine, sqlalchemy.engine.Engine)
     with sync_engine.begin() as conn:
         conn.execute(users.delete().where(users.c.id.in_(created_ids)))

packages/postgres-database/tests/test_models_groups.py

@@ -3,18 +3,14 @@
 # pylint: disable=unused-variable
 # pylint: disable=too-many-arguments
 
-from collections.abc import AsyncIterator, Awaitable, Callable
+from collections.abc import Callable
 
 import aiopg.sa.exc
 import pytest
-import sqlalchemy as sa
 from aiopg.sa.connection import SAConnection
-from aiopg.sa.engine import Engine
 from aiopg.sa.result import ResultProxy, RowProxy
 from psycopg2.errors import ForeignKeyViolation, RaiseException, UniqueViolation
-from pytest_simcore.helpers import postgres_tools
 from pytest_simcore.helpers.faker_factories import random_user
-from simcore_postgres_database.models.base import metadata
 from simcore_postgres_database.webserver_models import (
     GroupType,
     groups,
@@ -24,31 +20,6 @@
 from sqlalchemy import func, literal_column, select
 
 
-@pytest.fixture
-async def connection(
-    make_engine: Callable[[bool], Awaitable[Engine] | sa.engine.base.Engine]
-) -> AsyncIterator[SAConnection]:
-    # setup
-
-    sync_engine = make_engine(is_async=False)
-    metadata.drop_all(sync_engine)
-    metadata.create_all(sync_engine)
-
-    async_engine = await make_engine(is_async=True)
-    async with async_engine.acquire() as conn:
-        yield conn
-
-    # tear-down
-
-    try:
-        postgres_tools.force_drop_all_tables(sync_engine)
-    finally:
-        sync_engine.dispose()
-
-    async_engine.close()
-    await async_engine.wait_closed()
-
-
 async def test_user_group_uniqueness(
     connection: SAConnection,
     create_fake_group: Callable,

packages/postgres-database/tests/test_uniqueness_in_comp_tasks.py

@@ -1,15 +1,16 @@
-# pylint:disable=no-value-for-parameter
-# pylint:disable=unused-variable
-# pylint:disable=unused-argument
-# pylint:disable=redefined-outer-name
+# pylint: disable=redefined-outer-name
+# pylint: disable=unused-argument
+# pylint: disable=unused-variable
+# pylint: disable=too-many-arguments
 
 import json
-from collections.abc import Awaitable, Callable
+from collections.abc import AsyncIterator
 
 import aiopg.sa.engine
 import aiopg.sa.exc
 import pytest
 import sqlalchemy as sa
+import sqlalchemy.engine
 from psycopg2.errors import UniqueViolation  # pylint: disable=no-name-in-module
 from pytest_simcore.helpers import postgres_tools
 from pytest_simcore.helpers.faker_factories import fake_pipeline, fake_task_factory
@@ -21,30 +22,24 @@
 
 @pytest.fixture
 async def engine(
-    make_engine: Callable[[bool], Awaitable[aiopg.sa.engine.Engine] | sa.engine.Engine]
-):
-    async_engine: aiopg.sa.engine.Engine = await make_engine(is_async=True)
-    sync_engine: sa.engine.Engine = make_engine(is_async=False)
+    sync_engine: sqlalchemy.engine.Engine,
+    aiopg_engine: aiopg.sa.engine.Engine,
+) -> AsyncIterator[aiopg.sa.engine.Engine]:
+
     metadata.drop_all(sync_engine)
     metadata.create_all(sync_engine)
 
-    async with async_engine.acquire() as conn:
+    async with aiopg_engine.acquire() as conn:
         await conn.execute(
             comp_pipeline.insert().values(**fake_pipeline(project_id="PA"))
         )
         await conn.execute(
             comp_pipeline.insert().values(**fake_pipeline(project_id="PB"))
         )
 
-    yield async_engine
-
-    try:
-        postgres_tools.force_drop_all_tables(sync_engine)
-    finally:
-        sync_engine.dispose()
+    yield aiopg_engine
 
-    async_engine.close()
-    await async_engine.wait_closed()
+    postgres_tools.force_drop_all_tables(sync_engine)
 
 
 async def test_unique_project_node_pairs(engine):

packages/postgres-database/tests/test_utils_migration.py

@@ -3,10 +3,10 @@
 # pylint: disable=unused-argument
 # pylint: disable=unused-variable
 
-from collections.abc import Callable
 
 import pytest
 import simcore_postgres_database.cli
+import sqlalchemy.engine
 from alembic.script.revision import MultipleHeads
 from simcore_postgres_database.utils_migration import get_current_head
 from sqlalchemy import inspect
@@ -23,8 +23,8 @@ def test_migration_has_no_branches():
         )
 
 
-def test_migration_upgrade_downgrade(make_engine: Callable):
-    sync_engine = make_engine(is_async=False)
+def test_migration_upgrade_downgrade(sync_engine: sqlalchemy.engine.Engine):
+
     assert sync_engine
     assert simcore_postgres_database.cli.discover.callback
     assert simcore_postgres_database.cli.upgrade.callback

packages/service-library/src/servicelib/redis/_client.py

@@ -3,6 +3,7 @@
 import logging
 from asyncio import Task
 from dataclasses import dataclass, field
+from typing import Final
 from uuid import uuid4
 
 import redis.asyncio as aioredis
@@ -23,6 +24,9 @@
 
 _logger = logging.getLogger(__name__)
 
+# SEE https://github.com/ITISFoundation/osparc-simcore/pull/7077
+HEALTHCHECK_TASK_TIMEOUT_S: Final[float] = 3.0
+
 
 @dataclass
 class RedisClientSDK:
@@ -84,7 +88,9 @@ async def shutdown(self) -> None:
                 assert self._health_check_task_started_event  # nosec
                 # NOTE: wait for the health check task to have started once before we can cancel it
                 await self._health_check_task_started_event.wait()
-                await cancel_wait_task(self._health_check_task, max_delay=3)
+                await cancel_wait_task(
+                    self._health_check_task, max_delay=HEALTHCHECK_TASK_TIMEOUT_S
+                )
 
             await self._client.aclose(close_connection_pool=True)
 

services/web/server/src/simcore_service_webserver/log.py

@@ -18,9 +18,8 @@
     "gunicorn.access",
     "openapi_spec_validator",
     "servicelib.aiohttp.monitoring",
-    # TODO: this is temporary
-    # "sqlalchemy.engine",
-    # "sqlalchemy",
+    "sqlalchemy.engine",
+    "sqlalchemy",
     "socketio",
 )