fix tests add di to worker

Author: vladimirgubarik

app/application/repository/exceptions.py

@@ -1,4 +1,7 @@
-class BaseRepositoryError(Exception):
+from app.decorators.mapper.factories import ContextAwareError
+
+
+class BaseRepositoryError(ContextAwareError):
     """Base exception for all repository-specific exceptions."""
 
 
@@ -18,5 +21,17 @@ class RecordCreateError(BaseRepositoryError):
     """Raised when a creation fails."""
 
 
-class RecordRetreiveError(BaseRepositoryError):
+class RecordRetrieveError(BaseRepositoryError):
     """Raised when a get fails."""
+
+
+class RecordAlreadyExistsError(BaseRepositoryError):
+    """Raised when a record already exists."""
+
+
+class ForeignKeyError(BaseRepositoryError):
+    """Raised when a foreign key constraint is violated."""
+
+
+class ValidationError(BaseRepositoryError):
+    """Raised when a validation error occurs."""

app/application/use_cases/record_use_cases.py

@@ -20,7 +20,9 @@ def __init__(self, record_repo: ISampleRecordRepository):
     async def create_record(
         self, request_object: SampleRecordCreateRequestSchema
     ) -> SampleRecordResponseSchema:
-        domain_object = SampleRecord(record_data=request_object.record_data)
+        domain_object = SampleRecord(
+            record_data=request_object.record_data, name=request_object.name
+        )
         created_record = await self._repo.create(domain_object)
         return SampleRecordResponseSchema.from_orm(created_record)
 
@@ -29,7 +31,9 @@ async def update_record(
     ) -> SampleRecordResponseSchema:
         """Update an existing record."""
         domain_object = SampleRecord(
-            record_data=update_request.record_data, id=update_request.id
+            record_data=update_request.record_data,
+            id=update_request.id,
+            name=update_request.name
         )
         updated_record = await self._repo.update(domain_object)
         return SampleRecordResponseSchema.from_orm(updated_record)

app/domain/exceptions/__init__.py app/decorators/mapper/__init__.pyapp/domain/exceptions/__init__.py renamed to app/decorators/mapper/__init__.py

@@ -0,0 +1,52 @@
+from functools import cached_property
+from typing import Callable, Any
+
+
+class ExceptionContext:
+    SENSITIVE_KEYS: frozenset[str] = frozenset(
+        ("password", "token", "key", "secret", "auth", "credential", "passwd")
+    )
+
+    def __init__(
+        self,
+        original_exception: Exception,
+        func: Callable,
+        args: tuple[Any, ...],
+        kwargs: dict[str, Any],
+    ):
+        self.original_exception = original_exception
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
+
+    @cached_property
+    def formatted_context(self) -> str:
+        error_context = [
+            f"Error in function '{self.func.__module__}.{self.func.__qualname__}'"
+        ]
+
+        if self.args:
+            args_str = ", ".join(self._sanitised_value(arg) for arg in self.args)
+            error_context.append(f"Args: [{args_str}]")
+
+        if self.kwargs:
+            kwargs_str = ", ".join(
+                f"{k}={self._sanitised_value(v, k)}" for k, v in self.kwargs.items()
+            )
+            error_context.append(f"Kwargs: {kwargs_str}")
+
+        return "\n".join(error_context).replace("{", "{{").replace("}", "}}")
+
+    def _sanitised_value(
+        self,
+        value: Any,
+        key: str | None = None,
+    ) -> str:
+        if key is not None and key.lower() in self.SENSITIVE_KEYS:
+            return "****HIDDEN****"
+
+        try:
+            str_value = str(value)
+            return f"{str_value[:100]}..." if len(str_value) > 100 else str_value
+        except Exception:
+            return f"<{type(value).__name__} object - str() failed>"

app/decorators/mapper/context.py

@@ -1,100 +1,15 @@
 """Decorators to rethrow and log exceptions."""
 
-from abc import ABC, abstractmethod
-from functools import cached_property, wraps
+from functools import wraps
 from inspect import iscoroutinefunction
 from typing import Any, Callable, Type
 
 from cachetools import LRUCache  # type:ignore
 
+from app.decorators.mapper.context import ExceptionContext
+from app.decorators.mapper.factories import ExceptionFactory
 from app.logger import logger
 
-
-class ExceptionContext:
-    SENSITIVE_KEYS: frozenset[str] = frozenset(
-        ("password", "token", "key", "secret", "auth", "credential", "passwd")
-    )
-
-    def __init__(
-        self,
-        original_exception: Exception,
-        func: Callable,
-        args: tuple[Any, ...],
-        kwargs: dict[str, Any],
-    ):
-        self.original_exception = original_exception
-        self.func = func
-        self.args = args
-        self.kwargs = kwargs
-
-    @cached_property
-    def formatted_context(self) -> str:
-        error_context = [
-            f"Error in function '{self.func.__module__}.{self.func.__qualname__}'"
-        ]
-
-        if self.args:
-            args_str = ", ".join(self._sanitised_value(arg) for arg in self.args)
-            error_context.append(f"Args: [{args_str}]")
-
-        if self.kwargs:
-            kwargs_str = ", ".join(
-                f"{k}={self._sanitised_value(v, k)}" for k, v in self.kwargs.items()
-            )
-            error_context.append(f"Kwargs: {kwargs_str}")
-
-        return "\n".join(error_context).replace("{", "{{").replace("}", "}}")
-
-    def _sanitised_value(
-        self,
-        value: Any,
-        key: str | None = None,
-    ) -> str:
-        if key is not None and key.lower() in self.SENSITIVE_KEYS:
-            return "****HIDDEN****"
-
-        try:
-            str_value = str(value)
-            return f"{str_value[:100]}..." if len(str_value) > 100 else str_value
-        except Exception:
-            return f"<{type(value).__name__} object - str() failed>"
-
-
-class ExceptionFactory(ABC):
-    """
-    Create and describe a factory for exceptions.
-
-    This class is an abstract base class meant to define the interface for an
-    exception factory.
-
-    """
-
-    @abstractmethod
-    def make_exception(self, context: ExceptionContext) -> Exception:
-        """Make an exception based on the given context."""
-
-
-class EnrichedExceptionFactory(ExceptionFactory):
-    """
-    Create and manage enriched exceptions based on a given exception type.
-
-    This class provides a mechanism to create exceptions dynamically,
-    enriching them with a formatted context. It extends the behavior of
-    the base ExceptionFactory class by incorporating the concept of a
-    generated error type and formatted context.
-
-    :ivar generated_error: The type of exception to generate when creating
-                           an enriched exception.
-    :type generated_error: type[Exception]
-    """
-
-    def __init__(self, generated_error: type[Exception]):
-        self.generated_error = generated_error
-
-    def make_exception(self, context: ExceptionContext) -> Exception:
-        return self.generated_error(context.formatted_context)
-
-
 ExceptionOrTupleOfExceptions = Type[Exception] | tuple[Type[Exception], ...]
 
 
@@ -105,13 +20,11 @@ def __init__(
         self,
         exception_map: dict[ExceptionOrTupleOfExceptions, ExceptionFactory],
         max_cache_size: int = 512,
-        log_error: bool = True,
         is_bound_method: bool = False,
     ):
-        self.mapping = self._get_flat_map(exception_map)
+        self.mapping = self._get_exceptions_flat_map(exception_map)
         self.exception_catchall_factory = self.mapping.pop(Exception, None)
         self._lru_cache: LRUCache = LRUCache(maxsize=max_cache_size)
-        self.log_error = log_error
         self.is_bound_method = is_bound_method
 
     def __call__(self, func: Callable) -> Callable:
@@ -121,7 +34,7 @@ def __call__(self, func: Callable) -> Callable:
             else self._sync_wrapper(func)
         )
 
-    def _get_flat_map(
+    def _get_exceptions_flat_map(
         self,
         exception_map: dict[ExceptionOrTupleOfExceptions, ExceptionFactory],
     ) -> dict[Type[Exception], ExceptionFactory]:
@@ -164,11 +77,8 @@ def _handle_exception_logic(
         args: tuple[Any, ...],
         kwargs: dict[str, Any],
     ) -> None:
-        context = ExceptionContext(exc, func, self._filtered_args(args), kwargs)
-        if self.log_error:
-            logger.error(context.formatted_context, exc_info=True)
-
         if exception_factory := self._get_exception_factory(type(exc)):
+            context = ExceptionContext(exc, func, self._filtered_args(args), kwargs)
             raise exception_factory.make_exception(context) from exc
 
         raise exc

app/decorators/exception_mapper.py app/decorators/mapper/exception_mapper.pyapp/decorators/exception_mapper.py renamed to app/decorators/mapper/exception_mapper.py

@@ -0,0 +1,60 @@
+from abc import ABC, abstractmethod
+
+from app.decorators.mapper.context import ExceptionContext
+
+
+class ContextAwareError(Exception):
+    def __init__(self, message: str, context: ExceptionContext = None, *args):
+        super().__init__(message, *args)
+        self.context = context
+
+    def __str__(self) -> str:
+        base = super().__str__()
+        if self.context:
+            return f"{base} | context={self.context.formatted_context}"
+        return base
+
+
+class ExceptionFactory(ABC):
+    """
+    Create and describe a factory for exceptions.
+
+    This class is an abstract base class meant to define the interface for an
+    exception factory.
+
+    """
+
+    @abstractmethod
+    def make_exception(self, context: ExceptionContext) -> Exception:
+        """Make an exception based on the given context."""
+
+
+class PassThroughExceptionFactory(ExceptionFactory):
+    """Factory for exceptions that should be passed through without create a new one.
+
+    Useful for cases when broad Exception cached and wrapped to a common Exception type.
+    """
+
+    def make_exception(self, context: ExceptionContext) -> Exception:
+        return context.original_exception
+
+
+class EnrichedExceptionFactory(ExceptionFactory):
+    """
+    Create and manage enriched exceptions based on a given exception type.
+
+    This class provides a mechanism to create exceptions dynamically,
+    enriching them with a formatted context. It extends the behavior of
+    the base ExceptionFactory class by incorporating the concept of a
+    generated error type and formatted context.
+
+    :ivar generated_error: The type of exception to generate when creating
+                           an enriched exception.
+    :type generated_error: type[Exception]
+    """
+
+    def __init__(self, generated_error: type[ContextAwareError]):
+        self.generated_error = generated_error
+
+    def make_exception(self, context: ExceptionContext) -> ContextAwareError:
+        return self.generated_error(str(context.original_exception), context=context)

app/decorators/mapper/factories.py

@@ -2,23 +2,16 @@
 
 from dataclasses import dataclass
 
-from app.domain.exceptions.domain_exceptions import WrongRecordDataError
 
 
 @dataclass
 class SampleRecord:
     """Record entity representing a simple record in the system."""
 
     record_data: str
+    name: str
     id: int | None = None
 
     def __str__(self) -> str:
         """Return string representation of the record."""
-        return self.record_data
-
-    def __post_init__(self) -> None:
-        """Insert business validation here
-        For example for some reason record data shouldn't start with A123
-        """
-        if self.record_data.startswith("A123"):
-            raise WrongRecordDataError("Record data shouldn't start with A")
+        return f"id={self.id}, record_data={self.record_data}, name={self.name}"