Merge pull request #539 from camunda-community-hub/add-ZeebeError

feat: add ZeebeError for all Zeebe errors
camunda-community-hub · Dec 6, 2024 · 3533397 · 3533397
2 parents a60ba59 + d9b2651
commit 3533397
Show file tree

Hide file tree

Showing 5 changed files with 70 additions and 18 deletions.
diff --git a/docs/errors.rst b/docs/errors.rst
@@ -34,6 +34,8 @@ All ``pyzeebe`` errors inherit from :py:class:`PyZeebeError`
 
 .. autoexception:: pyzeebe.errors.InvalidJSONError
 
+.. autoexception:: pyzeebe.errors.ZeebeError
+
 .. autoexception:: pyzeebe.errors.ZeebeBackPressureError
 
 .. autoexception:: pyzeebe.errors.ZeebeGatewayUnavailableError

diff --git a/pyzeebe/errors/__init__.py b/pyzeebe/errors/__init__.py
@@ -25,6 +25,7 @@
     UnknownGrpcStatusCodeError,
     ZeebeBackPressureError,
     ZeebeDeadlineExceeded,
+    ZeebeError,
     ZeebeGatewayUnavailableError,
     ZeebeInternalError,
 )
@@ -52,4 +53,5 @@
     "ZeebeDeadlineExceeded",
     "ZeebeGatewayUnavailableError",
     "ZeebeInternalError",
+    "ZeebeError",
 )
diff --git a/pyzeebe/errors/zeebe_errors.py b/pyzeebe/errors/zeebe_errors.py
@@ -3,29 +3,47 @@
 from pyzeebe.errors.pyzeebe_errors import PyZeebeError
 
 
-class ZeebeBackPressureError(PyZeebeError):
+class ZeebeError(PyZeebeError):
+    """Base exception for all Zeebe errors."""
+
+    def __init__(self, grpc_error: grpc.aio.AioRpcError):
+        super().__init__()
+        self.grpc_error = grpc_error
+
+    def __str__(self) -> str:
+        return "{}(grpc_error={}(code={}, details={}, debug_error_string={}))".format(
+            self.__class__.__qualname__,
+            self.grpc_error.__class__.__qualname__,
+            self.grpc_error._code,
+            self.grpc_error._details,
+            self.grpc_error._debug_error_string,
+        )
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+
+class ZeebeBackPressureError(ZeebeError):
     """If Zeebe is currently in back pressure (too many requests)
 
     See: https://docs.camunda.io/docs/self-managed/zeebe-deployment/operations/backpressure/
     """
 
 
-class ZeebeGatewayUnavailableError(PyZeebeError):
+class ZeebeGatewayUnavailableError(ZeebeError):
     pass
 
 
-class ZeebeInternalError(PyZeebeError):
+class ZeebeInternalError(ZeebeError):
     pass
 
 
-class ZeebeDeadlineExceeded(PyZeebeError):
+class ZeebeDeadlineExceeded(ZeebeError):
     """If Zeebe hasn't responded after a certain timeout
 
     See: https://grpc.io/docs/guides/deadlines/
     """
 
 
-class UnknownGrpcStatusCodeError(PyZeebeError):
-    def __init__(self, grpc_error: grpc.aio.AioRpcError):
-        super().__init__()
-        self.grpc_error = grpc_error
+class UnknownGrpcStatusCodeError(ZeebeError):
+    pass
diff --git a/pyzeebe/grpc_internals/zeebe_adapter_base.py b/pyzeebe/grpc_internals/zeebe_adapter_base.py
@@ -54,11 +54,11 @@ async def _close(self) -> None:
 
 def _create_pyzeebe_error_from_grpc_error(grpc_error: grpc.aio.AioRpcError) -> PyZeebeError:
     if is_error_status(grpc_error, grpc.StatusCode.RESOURCE_EXHAUSTED):
-        return ZeebeBackPressureError()
+        return ZeebeBackPressureError(grpc_error)
     if is_error_status(grpc_error, grpc.StatusCode.UNAVAILABLE, grpc.StatusCode.CANCELLED):
-        return ZeebeGatewayUnavailableError()
+        return ZeebeGatewayUnavailableError(grpc_error)
     if is_error_status(grpc_error, grpc.StatusCode.INTERNAL):
-        return ZeebeInternalError()
+        return ZeebeInternalError(grpc_error)
     elif is_error_status(grpc_error, grpc.StatusCode.DEADLINE_EXCEEDED):
-        return ZeebeDeadlineExceeded()
+        return ZeebeDeadlineExceeded(grpc_error)
     return UnknownGrpcStatusCodeError(grpc_error)
diff --git a/tests/unit/grpc_internals/zeebe_adapter_base_test.py b/tests/unit/grpc_internals/zeebe_adapter_base_test.py
@@ -28,44 +28,74 @@ def test_returns_false_when_current_retries_over_max(self, zeebe_adapter: ZeebeA
 class TestHandleRpcError:
     async def test_raises_internal_error_on_internal_error_status(self, zeebe_adapter: ZeebeAdapterBase):
         error = grpc.aio.AioRpcError(grpc.StatusCode.INTERNAL, None, None)
-        with pytest.raises(ZeebeInternalError):
+        with pytest.raises(ZeebeInternalError) as err:
             await zeebe_adapter._handle_grpc_error(error)
 
+        assert (
+            str(err.value)
+            == "ZeebeInternalError(grpc_error=AioRpcError(code=StatusCode.INTERNAL, details=None, debug_error_string=None))"
+        )
+
     async def test_raises_back_pressure_error_on_resource_exhausted(self, zeebe_adapter: ZeebeAdapterBase):
         error = grpc.aio.AioRpcError(grpc.StatusCode.RESOURCE_EXHAUSTED, None, None)
-        with pytest.raises(ZeebeBackPressureError):
+        with pytest.raises(ZeebeBackPressureError) as err:
             await zeebe_adapter._handle_grpc_error(error)
 
+        assert (
+            str(err.value)
+            == "ZeebeBackPressureError(grpc_error=AioRpcError(code=StatusCode.RESOURCE_EXHAUSTED, details=None, debug_error_string=None))"
+        )
+
     async def test_raises_deadline_exceeded_on_deadline_exceeded(self, zeebe_adapter: ZeebeAdapterBase):
         error = grpc.aio.AioRpcError(grpc.StatusCode.DEADLINE_EXCEEDED, None, None)
-        with pytest.raises(ZeebeDeadlineExceeded):
+        with pytest.raises(ZeebeDeadlineExceeded) as err:
             await zeebe_adapter._handle_grpc_error(error)
 
+        assert (
+            str(err.value)
+            == "ZeebeDeadlineExceeded(grpc_error=AioRpcError(code=StatusCode.DEADLINE_EXCEEDED, details=None, debug_error_string=None))"
+        )
+
     async def test_raises_gateway_unavailable_on_unavailable_status(
         self,
         zeebe_adapter: ZeebeAdapterBase,
     ):
         error = grpc.aio.AioRpcError(grpc.StatusCode.UNAVAILABLE, None, None)
-        with pytest.raises(ZeebeGatewayUnavailableError):
+        with pytest.raises(ZeebeGatewayUnavailableError) as err:
             await zeebe_adapter._handle_grpc_error(error)
 
+        assert (
+            str(err.value)
+            == "ZeebeGatewayUnavailableError(grpc_error=AioRpcError(code=StatusCode.UNAVAILABLE, details=None, debug_error_string=None))"
+        )
+
     async def test_raises_gateway_unavailable_on_cancelled_status(
         self,
         zeebe_adapter: ZeebeAdapterBase,
     ):
         error = grpc.aio.AioRpcError(grpc.StatusCode.CANCELLED, None, None)
 
-        with pytest.raises(ZeebeGatewayUnavailableError):
+        with pytest.raises(ZeebeGatewayUnavailableError) as err:
             await zeebe_adapter._handle_grpc_error(error)
 
+        assert (
+            str(err.value)
+            == "ZeebeGatewayUnavailableError(grpc_error=AioRpcError(code=StatusCode.CANCELLED, details=None, debug_error_string=None))"
+        )
+
     async def test_raises_unkown_grpc_status_code_on_unkown_status_code(
         self,
         zeebe_adapter: ZeebeAdapterBase,
     ):
         error = grpc.aio.AioRpcError("FakeGrpcStatus", None, None)
-        with pytest.raises(UnknownGrpcStatusCodeError):
+        with pytest.raises(UnknownGrpcStatusCodeError) as err:
             await zeebe_adapter._handle_grpc_error(error)
 
+        assert (
+            str(err.value)
+            == "UnknownGrpcStatusCodeError(grpc_error=AioRpcError(code=FakeGrpcStatus, details=None, debug_error_string=None))"
+        )
+
     async def test_closes_after_retries_exceeded(self, zeebe_adapter: ZeebeAdapterBase):
         error = grpc.aio.AioRpcError(grpc.StatusCode.UNAVAILABLE, None, None)