testing

Author: pcrespov

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

@@ -1,13 +1,12 @@
 """ Repository pattern, errors and data structures for models.tags
 """
-
-from typing import TypedDict
-
 from common_library.errors_classes import OsparcErrorMixin
 from sqlalchemy.ext.asyncio import AsyncConnection, AsyncEngine
+from typing_extensions import TypedDict
 
 from .utils_repos import pass_or_acquire_connection, transaction_context
 from .utils_tags_sql import (
+    TagAccessRightsDict,
     count_groups_with_given_access_rights_stmt,
     create_tag_stmt,
     delete_tag_access_rights_stmt,
@@ -20,12 +19,14 @@
     upsert_tags_access_rights_stmt,
 )
 
+__all__: tuple[str, ...] = ("TagAccessRightsDict",)
+
 
 #
 # Errors
 #
-class _BaseTagError(ValueError, OsparcErrorMixin):
-    pass
+class _BaseTagError(OsparcErrorMixin, Exception):
+    msg_template = "Tag repo error on tag {tag_id}"
 
 
 class TagNotFoundError(_BaseTagError):
@@ -245,7 +246,7 @@ async def has_access_rights(
         delete: bool = False,
     ) -> bool:
         async with pass_or_acquire_connection(self.engine, connection) as conn:
-            result = await conn.execute(
+            group_id_or_none = await conn.scalar(
                 has_access_rights_stmt(
                     tag_id=tag_id,
                     caller_user_id=caller_id,
@@ -254,31 +255,39 @@ async def has_access_rights(
                     delete=delete,
                 )
             )
-            return result.fetchone() is not None
+            return bool(group_id_or_none)
 
     async def list_access_rights(
         self,
         connection: AsyncConnection | None = None,
         *,
-        # target
         tag_id: int,
-    ):
+    ) -> list[TagAccessRightsDict]:
         async with pass_or_acquire_connection(self.engine, connection) as conn:
             result = await conn.execute(list_tag_group_access_stmt(tag_id=tag_id))
-            return [dict(row) for row in result.fetchall()]
+            return [
+                TagAccessRightsDict(
+                    tag_id=row.tag_id,
+                    group_id=row.group_id,
+                    read=row.read,
+                    write=row.write,
+                    delete=row.delete,
+                )
+                for row in result.fetchall()
+            ]
 
     async def create_or_update_access_rights(
         self,
         connection: AsyncConnection | None = None,
         *,
-        # target
         tag_id: int,
         group_id: int,
         # access-rights
         read: bool,
         write: bool,
         delete: bool,
-    ):
+    ) -> TagAccessRightsDict:
+
         async with transaction_context(self.engine, connection) as conn:
             result = await conn.execute(
                 upsert_tags_access_rights_stmt(
@@ -290,13 +299,20 @@ async def create_or_update_access_rights(
                 )
             )
             row = result.first()
-            return dict(row)
+            assert row is not None
+
+            return TagAccessRightsDict(
+                tag_id=row.tag_id,
+                group_id=row.group_id,
+                read=row.read,
+                write=row.write,
+                delete=row.delete,
+            )
 
     async def delete_access_rights(
         self,
         connection: AsyncConnection | None = None,
         *,
-        # target
         tag_id: int,
         group_id: int,
     ) -> bool:

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

@@ -9,6 +9,7 @@
 from simcore_postgres_database.models.tags_access_rights import tags_access_rights
 from simcore_postgres_database.models.users import users
 from sqlalchemy.dialects.postgresql import insert as pg_insert
+from typing_extensions import TypedDict
 
 _TAG_COLUMNS = [
     tags.c.id,
@@ -167,6 +168,21 @@ def delete_tag_stmt(*, user_id: int, tag_id: int):
 # ACCESS RIGHTS
 #
 
+_TAG_ACCESS_RIGHTS_COLS = [
+    tags_access_rights.c.tag_id,
+    tags_access_rights.c.group_id,
+    *_ACCESS_RIGHTS_COLUMNS,
+]
+
+
+class TagAccessRightsDict(TypedDict):
+    tag_id: int
+    group_id: int
+    # access rights
+    read: bool
+    write: bool
+    delete: bool
+
 
 def has_access_rights_stmt(
     *,
@@ -194,14 +210,16 @@ def has_access_rights_stmt(
         raise ValueError(msg)
 
     conditions.append(group_condition)
+
+    # access-right
     if read:
         conditions.append(tags_access_rights.c.read.is_(True))
     if write:
         conditions.append(tags_access_rights.c.write.is_(True))
     if delete:
         conditions.append(tags_access_rights.c.delete.is_(True))
 
-    return sa.select(tags_access_rights).where(
+    return sa.select(tags_access_rights.c.group_id).where(
         sa.and_(
             tags_access_rights.c.tag_id == tag_id,
             *conditions,
@@ -210,11 +228,9 @@ def has_access_rights_stmt(
 
 
 def list_tag_group_access_stmt(*, tag_id: int):
-    return sa.select(
-        tags_access_rights.c.tag_id,
-        tags_access_rights.c.group_id,
-        *_ACCESS_RIGHTS_COLUMNS,
-    ).where(tags_access_rights.c.tag_id == tag_id)
+    return sa.select(*_TAG_ACCESS_RIGHTS_COLS).where(
+        tags_access_rights.c.tag_id == tag_id
+    )
 
 
 def upsert_tags_access_rights_stmt(
@@ -226,7 +242,8 @@ def upsert_tags_access_rights_stmt(
     write: bool,
     delete: bool,
 ):
-    assert (user_id and group_id) or (not user_id and not group_id)  # nosec
+    assert not (user_id is None and group_id is None)  # nosec
+    assert not (user_id is not None and group_id is not None)  # nosec
 
     if user_id:
         assert not group_id  # nosec
@@ -252,11 +269,7 @@ def upsert_tags_access_rights_stmt(
             index_elements=["tag_id", "group_id"],
             set_={"read": read, "write": write, "delete": delete},
         )
-        .returning(
-            tags_access_rights.c.tag_id,
-            tags_access_rights.c.group_id,
-            *_ACCESS_RIGHTS_COLUMNS,
-        )
+        .returning(*_TAG_ACCESS_RIGHTS_COLS)
     )
 
 

services/web/server/src/simcore_service_webserver/tags/_service.py

@@ -7,7 +7,11 @@
 from models_library.groups import GroupID
 from models_library.users import UserID
 from servicelib.aiohttp.db_asyncpg_engine import get_async_engine
-from simcore_postgres_database.utils_tags import TagOperationNotAllowedError, TagsRepo
+from simcore_postgres_database.utils_tags import (
+    TagAccessRightsDict,
+    TagOperationNotAllowedError,
+    TagsRepo,
+)
 from sqlalchemy.ext.asyncio import AsyncEngine
 
 from .schemas import TagCreate, TagGet, TagUpdate
@@ -67,7 +71,7 @@ async def share_tag_with_group(
     tag_id: IdInt,
     group_id: GroupID,
     access_rights: AccessRightsDict,
-):
+) -> TagAccessRightsDict:
     """
     Raises:
         TagOperationNotAllowedError
@@ -78,10 +82,10 @@ async def share_tag_with_group(
         caller_id=caller_user_id, tag_id=tag_id, write=True
     ):
         raise TagOperationNotAllowedError(
-            operation="share.write", user_id=caller_user_id, tag_id=tag_id
+            operation="share or update", user_id=caller_user_id, tag_id=tag_id
         )
 
-    await repo.create_or_update_access_rights(
+    return await repo.create_or_update_access_rights(
         tag_id=tag_id,
         group_id=group_id,
         **access_rights,
@@ -95,6 +99,13 @@ async def unshare_tag_with_group(
     tag_id: IdInt,
     group_id: GroupID,
 ) -> bool:
+    """
+    Raises:
+        TagOperationNotAllowedError
+
+    Returns:
+        True if unshared (NOTE: will not raise if not found)
+    """
     repo = TagsRepo(get_async_engine(app))
 
     if not await repo.has_access_rights(
@@ -113,8 +124,8 @@ async def list_tag_groups(
     *,
     caller_user_id: UserID,
     tag_id: IdInt,
-):
-
+) -> list[TagAccessRightsDict]:
+    """Returns list of groups sharing this tag"""
     repo = TagsRepo(get_async_engine(app))
 
     if not await repo.has_access_rights(

services/web/server/src/simcore_service_webserver/tags/schemas.py

@@ -1,6 +1,5 @@
 import re
-from datetime import datetime
-from typing import Annotated, Any, Self
+from typing import Annotated, Self
 
 from common_library.groups_dicts import AccessRightsDict
 from models_library.api_schemas_webserver._base import InputSchema, OutputSchema
@@ -9,7 +8,7 @@
 from models_library.users import UserID
 from pydantic import Field, PositiveInt, StringConstraints
 from servicelib.request_keys import RQT_USERID_KEY
-from simcore_postgres_database.utils_tags import TagDict
+from simcore_postgres_database.utils_tags import TagAccessRightsDict, TagDict
 
 
 class TagRequestContext(RequestParameters):
@@ -95,10 +94,12 @@ class TagGroupGet(OutputSchema):
     read: bool
     write: bool
     delete: bool
-    # timestamps
-    created: datetime
-    modified: datetime
 
     @classmethod
-    def from_model(cls, data: dict[str, Any]) -> Self:
-        raise NotImplementedError
+    def from_model(cls, data: TagAccessRightsDict) -> Self:
+        return cls(
+            gid=data["group_id"],
+            read=data["read"],
+            write=data["write"],
+            delete=data["delete"],
+        )