✅ Fixes tests/unit/with_dbs/02/test_projects_metadata_handlers.py::test_new_project_with_parent_project_node (#8602)

Author: pcrespov

packages/pytest-simcore/src/pytest_simcore/helpers/webserver_projects.py

@@ -12,7 +12,10 @@
 from common_library.dict_tools import remap_keys
 from models_library.projects_nodes_io import NodeID
 from models_library.services_resources import ServiceResourcesDictHelpers
+from simcore_postgres_database import webserver_models
 from simcore_postgres_database.utils_projects_nodes import ProjectNodeCreate
+from simcore_postgres_database.utils_repos import transaction_context
+from simcore_service_webserver.db.plugin import get_asyncpg_engine
 from simcore_service_webserver.projects._groups_repository import (
     update_or_insert_project_group,
 )
@@ -129,11 +132,12 @@ async def create_project(
 
 
 async def delete_all_projects(app: web.Application):
-    from simcore_postgres_database.webserver_models import projects
 
-    db = app[PROJECT_DBAPI_APPKEY]
-    async with db.engine.acquire() as conn:
-        query = projects.delete()
+    engine = get_asyncpg_engine(app)
+    assert engine  # nosec
+
+    async with transaction_context(engine) as conn:
+        query = webserver_models.projects.delete()
         await conn.execute(query)
 
 

services/web/server/tests/conftest.py

@@ -15,6 +15,7 @@
 
 import pytest
 import simcore_service_webserver
+import tenacity
 from aiohttp.test_utils import TestClient
 from common_library.json_serialization import json_dumps
 from faker import Faker
@@ -191,9 +192,9 @@ async def logged_user(
         },
         check_if_succeeds=user_role != UserRole.ANONYMOUS,
     ) as user:
-        print("-----> logged in user", user["name"], user_role)
+        logging.info("-----> logged in user %s %s", user["name"], user_role)
         yield user
-        print("<----- logged out user", user["name"], user_role)
+        logging.info("<----- logged out user %s %s", user["name"], user_role)
 
 
 @pytest.fixture
@@ -206,14 +207,16 @@ def monkeypatch_setenv_from_app_config(
     def _patch(app_config: dict) -> EnvVarsDict:
         assert isinstance(app_config, dict)
 
-        print("  - app_config=\n", json_dumps(app_config, indent=1, sort_keys=True))
+        logging.info(
+            "  - app_config=\n%s", json_dumps(app_config, indent=1, sort_keys=True)
+        )
         envs: EnvVarsDict = {
             env_key: f"{env_value}"
             for env_key, env_value in convert_to_environ_vars(app_config).items()
         }
 
-        print(
-            "  - convert_to_environ_vars(app_cfg)=\n",
+        logging.info(
+            "  - convert_to_environ_vars(app_cfg)=\n%s",
             json_dumps(envs, indent=1, sort_keys=True),
         )
         return setenvs_from_dict(monkeypatch, envs)
@@ -351,7 +354,7 @@ async def _creator(  # noqa: PLR0915
         resp = await client.post(
             f"{url}", json=project_data, headers=headers
         )  # NOTE: MD <-- here is project created!
-        print(f"<-- created project response: {resp=}")
+        logging.info("<-- created project response: %r", resp)
         data, error = await assert_status(resp, expected_accepted_response)
         if error:
             assert not data
@@ -371,31 +374,32 @@ async def _creator(  # noqa: PLR0915
             retry=retry_if_exception_type(AssertionError),
         ):
             with attempt:
-                print(
-                    f"--> waiting for creation {attempt.retry_state.attempt_number}..."
+                logging.info(
+                    "--> waiting for creation %s...", attempt.retry_state.attempt_number
                 )
                 result = await client.get(urlparse(status_url).path)
                 data, error = await assert_status(result, status.HTTP_200_OK)
                 assert data
                 assert not error
                 task_status = TaskStatus.model_validate(data)
                 assert task_status
-                print(f"<-- status: {task_status.model_dump_json(indent=2)}")
+                logging.info("<-- status: %s", task_status.model_dump_json(indent=2))
                 assert task_status.done, "task incomplete"
-                print(
-                    f"-- project creation completed: {json.dumps(attempt.retry_state.retry_object.statistics, indent=2)}"
+                logging.info(
+                    "-- project creation completed: %s",
+                    json.dumps(attempt.retry_state.retry_object.statistics, indent=2),
                 )
 
         # get result GET /{task_id}/result
-        print("--> getting project creation result...")
+        logging.info("--> getting project creation result...")
         result = await client.get(urlparse(result_url).path)
         data, error = await assert_status(result, expected_creation_response)
         if error:
             assert not data
             return {}
         assert data
         assert not error
-        print(f"<-- result: {data}")
+        logging.info("<-- result: %r", data)
         new_project = data
 
         # Setup access rights to the project
@@ -415,11 +419,11 @@ async def _creator(  # noqa: PLR0915
                     delete=permissions["delete"],
                 )
         # Get project with already added access rights
-        print("--> getting project groups after access rights change...")
+        logging.info("--> getting project groups after access rights change...")
         url = client.app.router["list_project_groups"].url_for(project_id=data["uuid"])
         resp = await client.get(url.path)
         data, error = await assert_status(resp, status.HTTP_200_OK)
-        print(f"<-- result: {data}")
+        logging.info("<-- result: %r", data)
         new_project_access_rights = {}
         for item in data:
             new_project_access_rights.update(
@@ -493,8 +497,35 @@ async def _creator(  # noqa: PLR0915
 
     # cleanup projects
     for client, project_uuid in zip(used_clients, created_project_uuids, strict=True):
+        # NOTE: delete does not wait for completion
         url = client.app.router["delete_project"].url_for(project_id=project_uuid)
-        await client.delete(url.path)
+        resp = await client.delete(url.path)
+
+        if resp.ok:
+            # NOTE: If deleted OK, then let's wait until project is really gone
+            url = client.app.router["get_project"].url_for(project_id=project_uuid)
+            async for attempt in AsyncRetrying(
+                wait=wait_fixed(0.1),
+                stop=stop_after_delay(10),
+                reraise=True,
+                retry=retry_if_exception_type(tenacity.TryAgain),
+            ):
+                with attempt:
+                    logging.info(
+                        "--> waiting for deletion %s...",
+                        attempt.retry_state.attempt_number,
+                    )
+                    resp = await client.get(url.path)
+                    if resp.status == status.HTTP_200_OK:
+                        raise tenacity.TryAgain
+
+                    await assert_status(resp, status.HTTP_404_NOT_FOUND)
+                    logging.info(
+                        "-- project deletion completed: %s",
+                        json.dumps(
+                            attempt.retry_state.retry_object.statistics, indent=2
+                        ),
+                    )
 
 
 @pytest.fixture

services/web/server/tests/unit/with_dbs/02/test_projects_states_handlers.py

@@ -266,6 +266,7 @@ async def test_share_project_user_roles(
     rabbit_service: RabbitSettings,
     mock_dynamic_scheduler: None,
     client: TestClient,
+    other_client: TestClient,
     logged_user: dict,
     primary_group: dict[str, str],
     standard_groups: list[dict[str, str]],
@@ -274,9 +275,10 @@ async def test_share_project_user_roles(
     expected: ExpectedResponse,
     storage_subsystem_mock,
     mocked_dynamic_services_interface: dict[str, mock.Mock],
-    project_db_cleaner,
     request_create_project: Callable[..., Awaitable[ProjectDict]],
     exit_stack: contextlib.AsyncExitStack,
+    project_db_cleaner,
+    aiohttp_client: Callable,
 ):
     # Use-case: test how different user roles can access shared projects
     # Test with full access rights for all roles
@@ -300,23 +302,26 @@ async def test_share_project_user_roles(
         # user 1 can always get to his project
         await assert_get_same_project(client, new_project, expected.ok)
 
-    # get another user logged in now
+    #
+    # get another user logged in now. We create a new client to avoid session conflicts with request_create_project
+    # cleanup
+    #
     await log_client_in(
-        client,
+        other_client,
         {"role": user_role.name},
         enable_check=user_role != UserRole.ANONYMOUS,
         exit_stack=exit_stack,
     )
     if new_project:
         # user 2 can get the project if they have proper role permissions
         await assert_get_same_project(
-            client,
+            other_client,
             new_project,
             expected.ok,
         )
 
         # user 2 can list projects if they have proper role permissions
-        list_projects = await _list_projects(client, expected.ok)
+        list_projects = await _list_projects(other_client, expected.ok)
         expected_project_count = 1 if user_role != UserRole.ANONYMOUS else 0
         assert len(list_projects) == expected_project_count
 
@@ -325,13 +330,13 @@ async def test_share_project_user_roles(
         project_update["name"] = "my super name"
         project_update.pop("accessRights")
         await _replace_project(
-            client,
+            other_client,
             project_update,
             expected.no_content,
         )
 
         # user 2 can delete projects if they have proper role permissions
-        resp = await _delete_project(client, new_project)
+        resp = await _delete_project(other_client, new_project)
         await assert_status(
             resp,
             expected_status_code=expected.no_content,

services/web/server/tests/unit/with_dbs/conftest.py

@@ -263,6 +263,20 @@ async def client(
     return await aiohttp_client(web_server)
 
 
+@pytest.fixture
+async def other_client(
+    client: TestClient, aiohttp_client: Callable, web_server: TestServer
+) -> TestClient:
+    """Creates another client connected to the same app as 'client' fixture
+    This is convenient to login with multiple users in the same app instance
+    without interfering with each other's session cookies
+    """
+    assert client.app
+    client2 = await aiohttp_client(web_server)
+    assert client2 != client
+    return client2
+
+
 @pytest.fixture
 async def webserver_rpc_client(
     rabbitmq_rpc_client: Callable[[str], Awaitable[RabbitMQRPCClient]],