WIP: 🎨 Enh/error handler 500

.ruff.toml

@@ -42,6 +42,7 @@ select = [
 ]
 ignore = [
   "E501",   # line too long, handled by black
+  "I001",   # Minor incompatibilites with isort:https://docs.astral.sh/ruff/rules/unsorted-imports/#unsorted-imports-i001
   "S101",   # use of `assert` detected hanbled by pylance, does not support noseq
   "TID252", # [*] Relative imports from parent modules are banned
   "TRY300", # Checks for return statements in try blocks. SEE https://beta.ruff.rs/docs/rules/try-consider-else/

packages/models-library/src/models_library/rest_payloads.py

@@ -0,0 +1,107 @@
+""" Common models for RESPONSE payloads
+
+- Enveloped response body
+- Error model in Enveloped
+- Flash message
+
+NOTE: these are all Output models
+"""
+
+from typing import Any, ClassVar, TypeAlias
+
+from pydantic import BaseModel, ValidationError
+
+
+class OneError(BaseModel):
+    msg: str
+    # optional
+    kind: str | None = None
+    loc: str | None = None
+    ctx: dict[str, Any] | None = None
+
+    class Config:
+        schema_extra: ClassVar[dict[str, Any]] = {
+            "examples": [
+                # HTTP_422_UNPROCESSABLE_ENTITY
+                {
+                    "loc": "path.project_uuid",
+                    "msg": "value is not a valid uuid",
+                    "kind": "type_error.uuid",
+                },
+                # HTTP_401_UNAUTHORIZED
+                {
+                    "msg": "You have to activate your account via email, before you can login",
+                    "kind": "activation_required",
+                    "ctx": {"resend_email_url": "https://foo.io/resend?code=123456"},
+                },
+            ]
+        }
+
+    @classmethod
+    def from_exception(cls, exc: Exception) -> "OneError":
+        return cls(
+            msg=f"{exc}",  # str(exc) always exists
+            kind=exc.__class__.__name__,  # exception class name always exists
+        )
+
+
+class ManyErrors(BaseModel):
+    msg: str
+    details: list[OneError] = []
+
+    class Config:
+        schema_extra: ClassVar[dict[str, Any]] = {
+            "example": {
+                # Collects all errors in a body HTTP_422_UNPROCESSABLE_ENTITY
+                "msg": "Invalid field/s 'body.x, body.z' in request",
+                "details": [
+                    {
+                        "loc": "body.x",
+                        "msg": "field required",
+                        "kind": "value_error.missing",
+                    },
+                    {
+                        "loc": "body.z",
+                        "msg": "field required",
+                        "kind": "value_error.missing",
+                    },
+                ],
+            }
+        }
+
+
+OneOrManyErrors: TypeAlias = OneError | ManyErrors
+
+
+def loc_to_jq_filter(parts: tuple[int | str, ...]) -> str:
+    """Converts Loc into jq filter
+
+    SEE https://jqlang.github.io/jq/manual/#basic-filters
+    """
+    return "".join(["." + _ if isinstance(_, str) else f"[{_}]" for _ in parts])
+
+
+def create_error_model_from_validation_error(
+    validation_error: ValidationError, msg: str
+) -> OneOrManyErrors:
+    details = [
+        OneError(
+            msg=e["msg"],
+            kind=e["type"],
+            loc=loc_to_jq_filter(e["loc"]),
+            ctx=e.get("ctx", None),
+        )
+        for e in validation_error.errors()
+    ]
+
+    assert details  # nosec
+
+    if len(details) == 1:
+        return details[0]
+    return ManyErrors(msg=msg, details=details)
+
+
+class FlashMessage(BaseModel):
+    message: str
+    level: str = "INFO"
+    logger: str = "user"

packages/models-library/tests/test_rest_payloads.py

@@ -0,0 +1,139 @@
+# pylint: disable=broad-exception-caught
+# pylint: disable=redefined-outer-name
+# pylint: disable=too-many-arguments
+# pylint: disable=unused-argument
+# pylint: disable=unused-variable
+
+import pytest
+from faker import Faker
+from models_library.rest_payloads import (
+    ManyErrors,
+    OneError,
+    create_error_model_from_validation_error,
+    loc_to_jq_filter,
+)
+from pydantic import BaseModel, ValidationError
+
+
+class ActivationRequiredError(Exception):
+    ...
+
+
+@pytest.fixture
+def generic_exc() -> Exception:
+    try:
+        msg = "Needs to confirm email firt"
+        raise ActivationRequiredError(msg)  # noqa: TRY301
+    except Exception as exc:
+        return exc
+
+
+def test_minimal_error_model(faker: Faker):
+    minimal_error = OneError(msg=faker.sentence())
+    assert minimal_error.msg
+    assert not minimal_error.kind
+    assert not minimal_error.ctx
+
+
+def test_error_model_from_generic_exception(faker: Faker, generic_exc: Exception):
+    error_from_exception = OneError.from_exception(generic_exc)
+    assert error_from_exception.ctx is None
+
+
+def test_error_model_with_context(faker: Faker, generic_exc: Exception):
+    # e.g. HTTP_401_UNAUTHORIZED
+    error_with_context = OneError.from_exception(
+        generic_exc,
+        ctx={"resend_confirmation_url": faker.url()},
+    )
+
+    assert error_with_context.kind == "ActivationRequiredError"
+    assert error_with_context.ctx
+
+
+def test_to_jq_query():
+    #
+    # SEE https://jqlang.github.io/jq/manual/#basic-filters
+    #
+    # NOTE: Could eventually use https://pypi.org/project/jq/ to process them
+    #
+    assert loc_to_jq_filter(("a",)) == ".a", "Single field name failed"
+    assert loc_to_jq_filter((0,)) == "[0]", "Single index failed"
+    assert loc_to_jq_filter(("a", 0)) == ".a[0]", "Field name followed by index failed"
+    assert loc_to_jq_filter((0, "a")) == "[0].a", "Index followed by field name failed"
+    assert (
+        loc_to_jq_filter(("a", 0, "b")) == ".a[0].b"
+    ), "Field name, index, field name sequence failed"
+    assert (
+        loc_to_jq_filter((0, "a", 1)) == "[0].a[1]"
+    ), "Index, field name, index sequence failed"
+    assert (
+        loc_to_jq_filter(("a", 0, "b", 1, "c")) == ".a[0].b[1].c"
+    ), "Complex sequence with multiple fields and indices failed"
+    assert (
+        loc_to_jq_filter(("a", -1)) == ".a[-1]"
+    ), "Field name with negative index failed"
+
+
+class A(BaseModel):
+    index: int
+    required: bool
+
+
+class B(BaseModel):
+    items: list[A]
+    obj: A
+
+
+@pytest.fixture
+def one_error_exc(request: pytest.FixtureRequest) -> ValidationError:
+    try:
+        B.parse_obj(
+            {
+                "items": [
+                    {"index": 33, "required": True},
+                    {"index": "not an int", "required": True},  # `index` not int!
+                ],
+                "obj": {"index": 42, "required": False},
+            }
+        )
+    except ValidationError as err:
+        return err
+
+
+@pytest.fixture
+def many_error_exc(request: pytest.FixtureRequest) -> ValidationError:
+    try:
+        B.parse_obj(
+            {
+                "items": [
+                    {"index": "not an int", "required": False},  # `index` not int !
+                ],
+                "obj": {"index": 33},  # `required` missing !
+            }
+        )
+    except ValidationError as err:
+        return err
+
+
+def test_error_model_from_validation_error(
+    faker: Faker, one_error_exc: ValidationError
+):
+    # HTTP_422_UNPROCESSABLE_ENTITY
+    error_from_validation = create_error_model_from_validation_error(
+        one_error_exc, msg="Unprocessable entity in request"
+    )
+
+    assert isinstance(error_from_validation, OneError)
+
+
+def test_error_model_from_many_validation_error(
+    faker: Faker, many_error_exc: ValidationError
+):
+
+    # HTTP_422_UNPROCESSABLE_ENTITY
+    error_from_validation = create_error_model_from_validation_error(
+        many_error_exc, msg="Unprocessable entity in request"
+    )
+
+    assert isinstance(error_from_validation, ManyErrors)

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

@@ -7,7 +7,7 @@
 from aiohttp import ClientResponse
 from servicelib.aiohttp import status
 from servicelib.aiohttp.rest_responses import unwrap_envelope
-from servicelib.status_utils import get_code_display_name, is_error
+from servicelib.status_codes_utils import get_display_name, is_error
 
 
 async def assert_status(
@@ -81,13 +81,12 @@ def _do_assert_error(
 
     assert is_error(expected_status_code)
 
-    assert len(error["errors"]) == 1
+    assert error.get("message")  # required & non-nullable
 
-    err = error["errors"][0]
     if expected_msg:
-        assert expected_msg in err["message"]
+        assert expected_msg in error["errors"][0]["message"]
 
     if expected_error_code:
-        assert expected_error_code == err["code"]
+        assert expected_error_code == error["errors"][0]["code"]
 
     return data, error

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

@@ -2,7 +2,7 @@
 from unittest import mock
 
 from servicelib.aiohttp import status
-from servicelib.status_utils import get_code_display_name
+from servicelib.status_codes_utils import get_display_name
 from simcore_postgres_database.models.users import UserRole