removed unnecessary test

Author: sanderegg

services/web/server/tests/integration/01/notifications/test_rabbitmq_consumers.py

@@ -12,7 +12,6 @@
 import socketio
 import sqlalchemy as sa
 from aiohttp.test_utils import TestClient
-from aioresponses import aioresponses as AioResponsesMock
 from faker import Faker
 from models_library.api_schemas_webserver.socketio import SocketIORoomStr
 from models_library.progress_bar import ProgressReport
@@ -39,7 +38,6 @@
 )
 from servicelib.rabbitmq import RabbitMQClient
 from settings_library.rabbit import RabbitSettings
-from simcore_postgres_database.models.projects import projects
 from simcore_postgres_database.models.users import UserRole
 from simcore_service_webserver.application_settings import setup_settings
 from simcore_service_webserver.db.plugin import setup_db
@@ -58,11 +56,9 @@
 from simcore_service_webserver.socketio.messages import (
     SOCKET_IO_EVENT,
     SOCKET_IO_LOG_EVENT,
-    SOCKET_IO_NODE_UPDATED_EVENT,
 )
 from simcore_service_webserver.socketio.models import WebSocketNodeProgress
 from simcore_service_webserver.socketio.plugin import setup_socketio
-from sqlalchemy.ext.asyncio import AsyncEngine
 from tenacity import RetryError
 from tenacity.asyncio import AsyncRetrying
 from tenacity.retry import retry_always, retry_if_exception_type
@@ -402,90 +398,6 @@ async def mocked_dynamic_services_interface(
     return mock
 
 
-@pytest.mark.parametrize("user_role", [UserRole.GUEST], ids=str)
-@pytest.mark.parametrize(
-    "sender_same_user_id", [True, False], ids=lambda id_: f"same_sender_id={id_}"
-)
-@pytest.mark.parametrize(
-    "subscribe_to_logs", [True, False], ids=lambda id_: f"subscribed={id_}"
-)
-async def test_progress_computational_workflow(
-    mocked_dynamic_services_interface,
-    director_v2_service_mock: AioResponsesMock,
-    client: TestClient,
-    rabbitmq_publisher: RabbitMQClient,
-    user_project: ProjectDict,
-    create_socketio_connection: Callable[
-        [str | None, TestClient | None], Awaitable[tuple[socketio.AsyncClient, str]]
-    ],
-    mocker: MockerFixture,
-    sqlalchemy_async_engine: AsyncEngine,
-    subscribe_to_logs: bool,
-    # user
-    sender_same_user_id: bool,
-    sender_user_id: UserID,
-    # project
-    random_node_id_in_user_project: NodeID,
-    user_project_id: ProjectID,
-):
-    """
-    RabbitMQ (TOPIC) --> Webserver -->  DB (get project)
-                                        Redis --> webclient (socketio)
-
-    """
-    socket_io_conn, *_ = await create_socketio_connection(None, client)
-
-    mock_progress_handler = mocker.MagicMock()
-    socket_io_conn.on(SOCKET_IO_NODE_UPDATED_EVENT, handler=mock_progress_handler)
-
-    if subscribe_to_logs:
-        assert client.app
-        await project_logs.subscribe(client.app, user_project_id)
-    # this simulates the user openning the project
-    await get_socket_server(client.app).enter_room(
-        socket_io_conn.get_sid(), SocketIORoomStr.from_project_id(user_project_id)
-    )
-    progress_message = ProgressRabbitMessageNode(
-        user_id=sender_user_id,
-        project_id=user_project_id,
-        node_id=random_node_id_in_user_project,
-        progress_type=ProgressType.COMPUTATION_RUNNING,
-        report=ProgressReport(actual_value=0.3, total=1),
-    )
-    await rabbitmq_publisher.publish(progress_message.channel_name, progress_message)
-
-    call_expected = sender_same_user_id and subscribe_to_logs
-    if call_expected:
-        expected_call = jsonable_encoder(
-            progress_message, include={"node_id", "project_id"}
-        )
-        expected_call |= {
-            "data": user_project["workbench"][f"{random_node_id_in_user_project}"]
-        }
-        expected_call["data"]["progress"] = int(
-            progress_message.report.percent_value * 100
-        )
-        await _assert_handler_called_with_json(mock_progress_handler, expected_call)
-    else:
-        await _assert_handler_not_called(mock_progress_handler)
-
-    # check the database. doing it after the waiting calls above is safe
-    async with sqlalchemy_async_engine.connect() as conn:
-        assert projects is not None
-        result = await conn.execute(
-            sa.select(projects.c.workbench).where(
-                projects.c.uuid == str(user_project_id)
-            )
-        )
-        row = result.one()
-        project_workbench = dict(row[projects.c.workbench])
-        # NOTE: the progress might still be present but is not used anymore
-        assert (
-            project_workbench[f"{random_node_id_in_user_project}"].get("progress", 0)
-            == 0
-        )
-
-
 @pytest.mark.parametrize("user_role", [UserRole.GUEST], ids=str)
 @pytest.mark.parametrize("metrics_name", ["service_started", "service_stopped"])
 async def test_instrumentation_workflow(

services/web/server/tests/integration/01/test_computation.py

@@ -647,9 +647,44 @@ async def test_running_computation_sends_progress_updates_via_socketio(
         "expected progress updates to be sent via socketio, "
         f"but got {mock_progress_handler.call_count} calls"
     )
-    # check that the last progress update was for the SUCCESS state
-    last_call_args = mock_progress_handler.call_args_list[-1][0]
-    assert len(last_call_args) == 1, (
-        "expected the progress handler to be called with a single argument, "
-        f"but got {len(last_call_args)} arguments"
+
+    # Get all computational nodes from the workbench (exclude file-picker nodes)
+    computational_node_ids = {
+        node_id
+        for node_id, node_data in user_project["workbench"].items()
+        if node_data.get("key", "").startswith("simcore/services/comp/")
+    }
+
+    # Collect all node IDs that received progress updates
+    received_progress_node_ids = set()
+    for call_args in mock_progress_handler.call_args_list:
+        assert len(call_args[0]) == 1, (
+            "expected the progress handler to be called with a single argument, "
+            f"but got {len(call_args[0])} arguments"
+        )
+        message = call_args[0][0]
+        assert isinstance(
+            message, dict
+        ), f"expected message to be dict, got {type(message)}"
+        assert (
+            "node_id" in message
+        ), f"expected 'node_id' in message, got {message.keys()}"
+        assert (
+            "project_id" in message
+        ), f"expected 'project_id' in message, got {message.keys()}"
+        assert (
+            message["project_id"] == project_id
+        ), f"expected project_id to match {project_id}, got {message['project_id']}"
+        received_progress_node_ids.add(message["node_id"])
+
+    # Verify that progress updates were sent for ALL computational nodes
+    missing_nodes = computational_node_ids - received_progress_node_ids
+    assert not missing_nodes, (
+        f"expected progress updates for all computational nodes {computational_node_ids}, "
+        f"but missing updates for {missing_nodes}. "
+        f"Received updates for: {received_progress_node_ids}"
+    )
+
+    print(
+        f"✓ Successfully received progress updates for all {len(computational_node_ids)} computational nodes: {computational_node_ids}"
     )