errors templates

Author: pcrespov

packages/common-library/src/common_library/errors_classes.py

@@ -52,3 +52,47 @@ def error_context(self) -> dict[str, Any]:
     def error_code(self) -> str:
         assert isinstance(self, Exception), "subclass must be exception"  # nosec
         return create_error_code(self)
+
+
+class BaseOsparcError(OsparcErrorMixin, Exception): ...
+
+
+class NotFoundError(BaseOsparcError):
+    msg_template = "{resource} not found: id='{resource_id}'"
+
+
+class ForbiddenError(BaseOsparcError):
+    msg_template = "Access to {resource} is forbidden: id='{resource_id}'"
+
+
+def make_resource_error(
+    resource: str,
+    error_cls: type[BaseOsparcError],
+    base_exception: type[Exception] = Exception,
+) -> type[BaseOsparcError]:
+    """
+    Factory function to create a custom error class for a specific resource.
+
+    This function dynamically generates an error class that inherits from the provided
+    `error_cls` and optionally a `base_exception`. The generated error class automatically
+    includes the resource name and resource ID in its context and message.
+
+    See usage examples in test_errors_classes.py
+
+    LIMITATIONS: for the moment, exceptions produces with this factory cannot be serialized with pickle.
+    And therefore it cannot be used as exception of RabbitMQ-RPC interface
+    """
+
+    class _ResourceError(error_cls, base_exception):
+        def __init__(self, **ctx: Any):
+            ctx.setdefault("resource", resource)
+
+            # guesses identifer e.g. project_id, user_id
+            if resource_id := ctx.get(f"{resource.lower()}_id"):
+                ctx.setdefault("resource_id", resource_id)
+
+            super().__init__(**ctx)
+
+    resource_class_name = "".join(word.capitalize() for word in resource.split("_"))
+    _ResourceError.__name__ = f"{resource_class_name}{error_cls.__name__}"
+    return _ResourceError

packages/common-library/tests/test_errors_classes.py

@@ -9,24 +9,24 @@
 from typing import Any
 
 import pytest
-from common_library.errors_classes import OsparcErrorMixin
+from common_library.errors_classes import (
+    ForbiddenError,
+    NotFoundError,
+    OsparcErrorMixin,
+    make_resource_error,
+)
 
 
 def test_get_full_class_name():
-    class A(OsparcErrorMixin):
-        ...
+    class A(OsparcErrorMixin): ...
 
-    class B1(A):
-        ...
+    class B1(A): ...
 
-    class B2(A):
-        ...
+    class B2(A): ...
 
-    class C(B2):
-        ...
+    class C(B2): ...
 
-    class B12(B1, ValueError):
-        ...
+    class B12(B1, ValueError): ...
 
     assert B1._get_full_class_name() == "A.B1"
     assert C._get_full_class_name() == "A.B2.C"
@@ -159,3 +159,47 @@ class MyError(OsparcErrorMixin, ValueError):
         "message": "42 and 'missing=?'",
         "value": 42,
     }
+
+
+def test_resource_error_factory():
+    ProjectNotFoundError = make_resource_error("project", NotFoundError)
+
+    error_1 = ProjectNotFoundError(resource_id="abc123")
+    assert "resource_id" in error_1.error_context()
+    assert error_1.resource_id in error_1.message  # type: ignore
+
+
+def test_resource_error_factory_auto_detect_resource_id():
+    ProjectForbiddenError = make_resource_error("project", ForbiddenError)
+    error_2 = ProjectForbiddenError(project_id="abc123", other_id="foo")
+    assert (
+        error_2.resource_id == error_2.project_id  # type: ignore
+    ), "auto-detects project ids as resourceid"
+    assert error_2.other_id  # type: ignore
+    assert error_2.code == "BaseOsparcError.ForbiddenError.ProjectForbiddenError"
+
+    assert error_2.error_context() == {
+        "project_id": "abc123",
+        "other_id": "foo",
+        "resource": "project",
+        "resource_id": "abc123",
+        "message": "Access to project is forbidden: id='abc123'",
+        "code": "BaseOsparcError.ForbiddenError.ProjectForbiddenError",
+    }
+
+
+def test_resource_error_factory_different_base_exception():
+
+    class MyServiceError(Exception): ...
+
+    OtherProjectForbiddenError = make_resource_error(
+        "other_project", ForbiddenError, MyServiceError
+    )
+
+    assert issubclass(OtherProjectForbiddenError, MyServiceError)
+
+    error_3 = OtherProjectForbiddenError(project_id="abc123")
+    assert (
+        error_3.code
+        == "MyServiceError.BaseOsparcError.ForbiddenError.OtherProjectForbiddenError"
+    )