Fix test

Author: wvangeit

services/web/server/src/simcore_service_webserver/functions/_functions_repository.py

@@ -453,10 +453,9 @@ async def list_functions(
             search_by_function_title=search_by_function_title,
         )
 
-        # Build the base query with join to access rights table
+        # Use GROUP BY on the primary key to ensure unique functions
         base_query = (
             functions_table.select()
-            .distinct()
             .join(
                 functions_access_rights_table,
                 functions_table.c.uuid == functions_access_rights_table.c.function_uuid,
@@ -467,6 +466,7 @@ async def list_functions(
                 functions_access_rights_table.c.read,
                 *attributes_filters,
             )
+            .group_by(functions_table.c.uuid)
         )
 
         # Get total count

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

@@ -4,7 +4,7 @@
 
 
 from collections.abc import AsyncIterator, Awaitable, Callable
-from contextlib import AsyncExitStack
+from contextlib import AsyncExitStack, suppress
 from typing import Any
 from uuid import UUID, uuid4
 
@@ -18,6 +18,7 @@
     ProjectFunction,
 )
 from models_library.functions import FunctionClass, SolverFunction
+from models_library.functions_errors import FunctionWriteAccessDeniedError
 from models_library.products import ProductName
 from models_library.rabbitmq_basic_types import RPCNamespace
 from pydantic import TypeAdapter
@@ -152,23 +153,26 @@ async def clean_functions(
     client: TestClient,
     webserver_rpc_client: WebServerRpcClient,
     logged_user: UserInfoDict,
+    other_logged_user: UserInfoDict,
     osparc_product_name: ProductName,
 ) -> None:
     assert client.app
 
-    functions, _ = await webserver_rpc_client.functions.list_functions(
-        pagination_limit=100,
-        pagination_offset=0,
-        user_id=logged_user["id"],
-        product_name=osparc_product_name,
-    )
-    for function in functions:
-        assert function.uid is not None
-        await webserver_rpc_client.functions.delete_function(
-            function_id=function.uid,
-            user_id=logged_user["id"],
+    for user_id in (logged_user["id"], other_logged_user["id"]):
+        functions, _ = await webserver_rpc_client.functions.list_functions(
+            pagination_limit=100,
+            pagination_offset=0,
+            user_id=user_id,
             product_name=osparc_product_name,
         )
+        for function in functions:
+            assert function.uid is not None
+            with suppress(FunctionWriteAccessDeniedError):
+                await webserver_rpc_client.functions.delete_function(
+                    function_id=function.uid,
+                    user_id=user_id,
+                    product_name=osparc_product_name,
+                )
 
 
 @pytest.fixture

services/web/server/tests/unit/with_dbs/04/functions/wb-api-server/test_functions_controller_rpc.py

@@ -30,6 +30,7 @@
 from models_library.groups import EVERYONE_GROUP_ID
 from models_library.products import ProductName
 from models_library.rest_ordering import OrderBy, OrderDirection
+from models_library.rest_pagination import PageMetaInfoLimitOffset
 from pytest_simcore.helpers.webserver_users import UserInfoDict
 from servicelib.rabbitmq.rpc_interfaces.webserver.v1 import WebServerRpcClient
 
@@ -294,6 +295,7 @@ async def test_list_functions_mixed_user(
         user_id=logged_user["id"],
         product_name=osparc_product_name,
         read=True,
+        write=True,
     )
     other_functions, _ = await webserver_rpc_client.functions.list_functions(
         pagination_limit=10,
@@ -314,38 +316,48 @@ async def test_list_functions_mixed_user(
     ],
 )
 @pytest.mark.parametrize(
-    "test_pagination_limit, test_pagination_offset",
+    "test_pagination_limit, test_pagination_offset, total_number_functions",
     [
-        (5, 0),
-        (2, 2),
-        (12, 4),
+        (5, 0, 10),
+        (2, 2, 10),
+        (12, 4, 10),
     ],
 )
 async def test_list_functions_with_pagination_ordering(
     client: TestClient,
     add_user_function_api_access_rights: None,
     webserver_rpc_client: WebServerRpcClient,
     create_fake_function_obj: Callable[[FunctionClass], ProjectFunction],
-    clean_functions: None,
     osparc_product_name: ProductName,
     logged_user: UserInfoDict,
     order_by: OrderBy | None,
     test_pagination_limit: int,
     test_pagination_offset: int,
+    total_number_functions: int,
+    clean_functions: None,
 ):
+    # Making sure functions are empty before we start
+    assert await webserver_rpc_client.functions.list_functions(
+        pagination_limit=1,
+        pagination_offset=0,
+        user_id=logged_user["id"],
+        product_name=osparc_product_name,
+    ) == (
+        [],
+        PageMetaInfoLimitOffset(limit=1, total=0, offset=0, count=0),
+    )
     # Register multiple functions
-    TOTAL_FUNCTIONS = 10
     registered_functions = [
         await webserver_rpc_client.functions.register_function(
             function=create_fake_function_obj(FunctionClass.PROJECT),
             user_id=logged_user["id"],
             product_name=osparc_product_name,
         )
-        for _ in range(TOTAL_FUNCTIONS)
+        for _ in range(total_number_functions)
     ]
 
     # List functions with pagination
-    functions, page_info = await webserver_rpc_client.functions.list_functions(
+    listed_functions, page_info = await webserver_rpc_client.functions.list_functions(
         pagination_limit=test_pagination_limit,
         pagination_offset=test_pagination_offset,
         user_id=logged_user["id"],
@@ -354,23 +366,26 @@ async def test_list_functions_with_pagination_ordering(
     )
 
     # Assert the list contains the correct number of functions
-    assert len(functions) == min(
-        test_pagination_limit, max(0, TOTAL_FUNCTIONS - test_pagination_offset)
+    assert len(listed_functions) == min(
+        test_pagination_limit, max(0, total_number_functions - test_pagination_offset)
     )
-    assert all(f.uid in [rf.uid for rf in registered_functions] for f in functions)
-    assert page_info.count == len(functions)
-    assert page_info.total == TOTAL_FUNCTIONS
+
+    assert all(
+        f.uid in [rf.uid for rf in registered_functions] for f in listed_functions
+    )
+    assert page_info.count == len(listed_functions)
+    assert page_info.total == total_number_functions
 
     # Verify the functions are sorted correctly based on the order_by parameter
     if order_by:
         field = order_by.field
         direction = order_by.direction
         sorted_functions = sorted(
-            functions,
+            listed_functions,
             key=lambda f: getattr(f, field),
             reverse=(direction == OrderDirection.DESC),
         )
-        assert functions == sorted_functions
+        assert listed_functions == sorted_functions
 
 
 @pytest.mark.parametrize(