adds tests

Author: pcrespov

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

@@ -2,7 +2,7 @@
 import logging
 import warnings
 from dataclasses import dataclass, fields
-from typing import Any
+from typing import Any, Callable
 
 import sqlalchemy as sa
 from aiopg.sa.connection import SAConnection
@@ -135,10 +135,10 @@ async def get_v2(
             raise GroupExtraPropertiesNotFoundError(msg)
 
     @staticmethod
-    def _aggregate(rows, user_id, product_name):
+    def _aggregate(rows, user_id, product_name, from_row: Callable):
         merged_standard_extra_properties = None
         for row in rows:
-            group_extra_properties = GroupExtraProperties.from_row_proxy(row)
+            group_extra_properties = from_row(row)
             match row.type:
                 case GroupType.PRIMARY:
                     # this always has highest priority
@@ -198,7 +198,9 @@ async def get_aggregated_properties_for_user(
         rows: list[RowProxy] | None = await result.fetchall()
         assert rows is not None  # nosec
 
-        return GroupExtraPropertiesRepo._aggregate(rows, user_id, product_name)
+        return GroupExtraPropertiesRepo._aggregate(
+            rows, user_id, product_name, GroupExtraProperties.from_row_proxy
+        )
 
     @staticmethod
     async def get_aggregated_properties_for_user_v2(
@@ -217,4 +219,6 @@ async def get_aggregated_properties_for_user_v2(
                 sa.select(list_stmt).order_by(list_stmt.c.type_order)
             )
             rows = [row async for row in result]
-            return GroupExtraPropertiesRepo._aggregate(rows, user_id, product_name)
+            return GroupExtraPropertiesRepo._aggregate(
+                rows, user_id, product_name, GroupExtraProperties.from_orm
+            )

packages/postgres-database/tests/test_utils_groups_extra_properties.py

@@ -21,6 +21,7 @@
     GroupExtraPropertiesRepo,
 )
 from sqlalchemy import literal_column
+from sqlalchemy.ext.asyncio import AsyncEngine
 
 
 async def test_get_raises_if_not_found(
@@ -101,6 +102,28 @@ async def test_get(
     assert created_extra_properties == received_extra_properties
 
 
+async def test_get_v2(
+    asyncpg_engine: AsyncEngine,
+    registered_user: RowProxy,
+    product_name: str,
+    create_fake_product: Callable[..., Awaitable[RowProxy]],
+    create_fake_group_extra_properties: Callable[..., Awaitable[GroupExtraProperties]],
+):
+    with pytest.raises(GroupExtraPropertiesNotFoundError):
+        await GroupExtraPropertiesRepo.get_v2(
+            asyncpg_engine, gid=registered_user.primary_gid, product_name=product_name
+        )
+
+    await create_fake_product(product_name)
+    created_extra_properties = await create_fake_group_extra_properties(
+        registered_user.primary_gid, product_name
+    )
+    received_extra_properties = await GroupExtraPropertiesRepo.get_v2(
+        asyncpg_engine, gid=registered_user.primary_gid, product_name=product_name
+    )
+    assert created_extra_properties == received_extra_properties
+
+
 @pytest.fixture
 async def everyone_group_id(connection: aiopg.sa.connection.SAConnection) -> int:
     result = await connection.scalar(
@@ -355,3 +378,114 @@ async def test_get_aggregated_properties_for_user_returns_property_values_as_tru
     assert aggregated_group_properties.internet_access is False
     assert aggregated_group_properties.override_services_specifications is False
     assert aggregated_group_properties.use_on_demand_clusters is True
+
+
+async def test_get_aggregated_properties_for_user_returns_property_values_as_truthy_if_one_of_them_is_v2(
+    asyncpg_engine: AsyncEngine,
+    connection: aiopg.sa.connection.SAConnection,
+    product_name: str,
+    registered_user: RowProxy,
+    create_fake_product: Callable[..., Awaitable[RowProxy]],
+    create_fake_group: Callable[..., Awaitable[RowProxy]],
+    create_fake_group_extra_properties: Callable[..., Awaitable[GroupExtraProperties]],
+    everyone_group_id: int,
+):
+    await create_fake_product(product_name)
+    await create_fake_product(f"{product_name}_additional_just_for_fun")
+
+    # create a specific extra properties for group that disallow everything
+    everyone_group_extra_properties = await create_fake_group_extra_properties(
+        everyone_group_id,
+        product_name,
+        internet_access=False,
+        override_services_specifications=False,
+        use_on_demand_clusters=False,
+    )
+    # this should return the everyone group properties
+    aggregated_group_properties = (
+        await GroupExtraPropertiesRepo.get_aggregated_properties_for_user_v2(
+            asyncpg_engine, user_id=registered_user.id, product_name=product_name
+        )
+    )
+    assert aggregated_group_properties == everyone_group_extra_properties
+
+    # now we create some standard groups and add the user to them and make everything false for now
+    standard_groups = [await create_fake_group(connection) for _ in range(5)]
+    for group in standard_groups:
+        await create_fake_group_extra_properties(
+            group.gid,
+            product_name,
+            internet_access=False,
+            override_services_specifications=False,
+            use_on_demand_clusters=False,
+        )
+        await _add_user_to_group(
+            connection, user_id=registered_user.id, group_id=group.gid
+        )
+
+    # now we still should not have any of these value Truthy
+    aggregated_group_properties = (
+        await GroupExtraPropertiesRepo.get_aggregated_properties_for_user_v2(
+            asyncpg_engine, user_id=registered_user.id, product_name=product_name
+        )
+    )
+    assert aggregated_group_properties.internet_access is False
+    assert aggregated_group_properties.override_services_specifications is False
+    assert aggregated_group_properties.use_on_demand_clusters is False
+
+    # let's change one of these standard groups
+    random_standard_group = random.choice(standard_groups)  # noqa: S311
+    result = await connection.execute(
+        groups_extra_properties.update()
+        .where(groups_extra_properties.c.group_id == random_standard_group.gid)
+        .values(internet_access=True)
+    )
+    assert result.rowcount == 1
+
+    # now we should have internet access
+    aggregated_group_properties = (
+        await GroupExtraPropertiesRepo.get_aggregated_properties_for_user_v2(
+            asyncpg_engine, user_id=registered_user.id, product_name=product_name
+        )
+    )
+    assert aggregated_group_properties.internet_access is True
+    assert aggregated_group_properties.override_services_specifications is False
+    assert aggregated_group_properties.use_on_demand_clusters is False
+
+    # let's change another one of these standard groups
+    random_standard_group = random.choice(standard_groups)  # noqa: S311
+    result = await connection.execute(
+        groups_extra_properties.update()
+        .where(groups_extra_properties.c.group_id == random_standard_group.gid)
+        .values(override_services_specifications=True)
+    )
+    assert result.rowcount == 1
+
+    # now we should have internet access and service override
+    aggregated_group_properties = (
+        await GroupExtraPropertiesRepo.get_aggregated_properties_for_user_v2(
+            asyncpg_engine, user_id=registered_user.id, product_name=product_name
+        )
+    )
+    assert aggregated_group_properties.internet_access is True
+    assert aggregated_group_properties.override_services_specifications is True
+    assert aggregated_group_properties.use_on_demand_clusters is False
+
+    # and we can deny it again by setting a primary extra property
+    # now create some personal extra properties
+    personal_group_extra_properties = await create_fake_group_extra_properties(
+        registered_user.primary_gid,
+        product_name,
+        internet_access=False,
+        use_on_demand_clusters=True,
+    )
+    assert personal_group_extra_properties
+
+    aggregated_group_properties = (
+        await GroupExtraPropertiesRepo.get_aggregated_properties_for_user_v2(
+            asyncpg_engine, user_id=registered_user.id, product_name=product_name
+        )
+    )
+    assert aggregated_group_properties.internet_access is False
+    assert aggregated_group_properties.override_services_specifications is False
+    assert aggregated_group_properties.use_on_demand_clusters is True

packages/postgres-database/tests/test_utils_projects.py

@@ -3,9 +3,9 @@
 # pylint: disable=unused-variable
 # pylint: disable=too-many-arguments
 import uuid
-from collections.abc import Awaitable, Callable
-from datetime import datetime, timezone
-from typing import Any, AsyncIterator
+from collections.abc import AsyncIterator, Awaitable, Callable
+from datetime import UTC, datetime
+from typing import Any
 
 import pytest
 import sqlalchemy as sa
@@ -53,7 +53,7 @@ async def registered_project(
     await _delete_project(connection, project["uuid"])
 
 
-@pytest.mark.parametrize("expected", (datetime.now(tz=timezone.utc), None))
+@pytest.mark.parametrize("expected", (datetime.now(tz=UTC), None))
 async def test_get_project_trashed_at_column_can_be_converted_to_datetime(
     asyncpg_engine: AsyncEngine, registered_project: dict, expected: datetime | None
 ):