add integration tests for bot commands

Author: vladimirgubarik

app/application/repository/interfaces.py

@@ -1,7 +1,7 @@
 """Record repository interface."""
 
 from abc import ABC, abstractmethod
-from typing import List
+from typing import List, Self
 
 from app.domain.entities.sample_record import SampleRecord
 
@@ -23,6 +23,7 @@ class ISampleRecordUnitOfWork(IUnitOfWork, ABC):
 
     @abstractmethod
     def get_sample_record_repository(self) -> "ISampleRecordRepository":
+        """Return an initialized ISampleRecordRepository object implementation."""
         pass
 
 
@@ -81,7 +82,3 @@ async def get_all(self) -> List[SampleRecord]:
         """Get all records from the database"""
         pass
 
-    @abstractmethod
-    async def commit(self) -> None:
-        """Commit changes to the database"""
-        pass

app/application/use_cases/record_use_cases.py

@@ -12,7 +12,7 @@
 
 
 class SampleRecordUseCases(ISampleRecordUseCases):
-    """Implementation of record use cases."""
+    """Implementation of samplr record use cases."""
 
     def __init__(self, record_repo: ISampleRecordRepository):
         self._repo = record_repo

app/decorators/mapper/context.py

@@ -3,6 +3,7 @@
 
 
 class ExceptionContext:
+    """Class to store exception rising context."""
     SENSITIVE_KEYS: frozenset[str] = frozenset(
         ("password", "token", "key", "secret", "auth", "credential", "passwd")
     )
@@ -21,6 +22,8 @@ def __init__(
 
     @cached_property
     def formatted_context(self) -> str:
+        """Format exception context for logging.
+        """
         error_context = [
             f"Error in function '{self.func.__module__}.{self.func.__qualname__}'"
         ]
@@ -42,6 +45,10 @@ def _sanitised_value(
         value: Any,
         key: str | None = None,
     ) -> str:
+        """Exclude sensitive data from logging
+
+        TODO: add deeper sanitation for nested structures
+        """
         if key is not None and key.lower() in self.SENSITIVE_KEYS:
             return "****HIDDEN****"
 

app/decorators/mapper/exception_mapper.py

@@ -14,7 +14,10 @@
 
 
 class ExceptionMapper:
-    """Exception-mapping decorator with bounded LRU caching and dynamic MRO lookup."""
+    """Exception-mapping decorator with bounded LRU caching and dynamic MRO lookup.
+
+    The main decorator purpose is map exception between application layers and enrich exceptions by context.
+    """
 
     def __init__(
         self,
@@ -38,6 +41,7 @@ def _get_exceptions_flat_map(
         self,
         exception_map: dict[ExceptionOrTupleOfExceptions, ExceptionFactory],
     ) -> dict[Type[Exception], ExceptionFactory]:
+        """Do a flat map from given exception map."""
         flat_map: dict[Type[Exception], ExceptionFactory] = {}
         for exception_class, factory in exception_map.items():
             if isinstance(exception_class, tuple):
@@ -96,7 +100,7 @@ def _get_exception_factory(
                 self._lru_cache[exc_type] = target_exception_factory
                 return target_exception_factory
 
-        # exception is not presented in base mapping, but Exception in base mapping
+        # exception is not presented in base mapping, but catchall presented in mapping dict
         if self.exception_catchall_factory:
             self._lru_cache[exc_type] = self.exception_catchall_factory
             return self.exception_catchall_factory

app/infrastructure/repositories/sample_record.py

@@ -13,7 +13,8 @@
     RecordUpdateError,
     RecordAlreadyExistsError,
     ForeignKeyError,
-    ValidationError, BaseRepositoryError,
+    ValidationError,
+    BaseRepositoryError,
 )
 from app.application.repository.interfaces import ISampleRecordRepository
 from app.decorators.mapper.exception_mapper import (
@@ -58,15 +59,6 @@ def __init__(self, session: AsyncSession):
         """
         self._session = session
 
-    @ExceptionMapper(
-        {
-            Exception: EnrichedExceptionFactory(BaseRepositoryError),
-        },
-        is_bound_method=True,
-    )
-    async def commit(self) -> None:
-        await self._session.commit()
-
     @ExceptionMapper(
         {
             IntegrityError: IntegrityErrorFactory(RecordCreateError),

app/main.py

@@ -33,7 +33,6 @@ async def shutdown(
     await container.callback_task_manager().shutdown()
 
     await container.redis_client().aclose()
-    await container.shutdown_resources()
     await get_engine().dispose()
 
 

app/presentation/bot/command_handlers/sample_record.py

@@ -7,8 +7,10 @@
     RecordAlreadyExistsError,
     RecordDoesNotExistError,
 )
-from app.application.repository.interfaces import ISampleRecordUnitOfWork, \
-    ISampleRecordRepository
+from app.application.repository.interfaces import (
+    ISampleRecordUnitOfWork,
+    ISampleRecordRepository,
+)
 from app.application.use_cases.interfaces import ISampleRecordUseCases
 from app.presentation.bot.command_handlers.base_handler import BaseCommandHandler
 from app.presentation.bot.error_handlers.exceptions_chain_executor import (
@@ -54,7 +56,7 @@ def __init__(
         bot: Bot,
         message: IncomingMessage,
         unit_of_work: ISampleRecordUnitOfWork,
-        use_case_factory: Callable[[ISampleRecordRepository], ISampleRecordUseCases]
+        use_case_factory: Callable[[ISampleRecordRepository], ISampleRecordUseCases],
     ):
         self._use_cases = use_case_factory
         self.unit_of_work = unit_of_work
@@ -97,17 +99,23 @@ def __init__(
         self,
         bot: Bot,
         message: IncomingMessage,
-        use_cases: ISampleRecordUseCases,
+        unit_of_work: ISampleRecordUnitOfWork,
+        use_case_factory: Callable[[ISampleRecordRepository], ISampleRecordUseCases],
     ):
-        self._use_cases = use_cases
+        self._use_cases = use_case_factory
+        self.unit_of_work = unit_of_work
 
         super().__init__(bot, message, self.exception_handler_chain_executor)
 
     async def handle_logic(
         self,
         request_parameter: SampleRecordDeleteRequestSchema,  # type: ignore
     ) -> None:
-        await self._use_cases.delete_record(request_parameter.id)
+        async with self.unit_of_work as uof:
+            await self._use_cases(uof.get_sample_record_repository()).delete_record(
+                request_parameter.id
+            )
+
         await self._bot.answer_message(
             SAMPLE_RECORD_DELETED_ANSWER.format(
                 id=request_parameter.id,

app/presentation/bot/commands/sample_record.py

@@ -11,7 +11,7 @@
     BotSampleRecordCommandContainer,
     ApplicationStartupContainer,
 )
-from app.infrastructure.db.sqlalchemy import provide_session
+
 from app.infrastructure.repositories.unit_of_work import WriteSampleRecordUnitOfWork
 from app.presentation.bot.commands.command_listing import SampleRecordCommands
 from app.presentation.bot.command_handlers.sample_record import (
@@ -23,16 +23,16 @@
 
 
 @collector.command(**SampleRecordCommands.CREATE_RECORD.command_data())
-# @provide_session
 @inject
 async def create_sample_record(
     message: IncomingMessage,
     bot: Bot,
-    # session: AsyncSession,
-    unit_of_work: WriteSampleRecordUnitOfWork=Provide[BotSampleRecordCommandContainer.rw_unit_of_work],
-    record_use_cases_factory: Callable[[ISampleRecordRepository], ISampleRecordUseCases] = Provider[
-        BotSampleRecordCommandContainer.record_use_cases_factory
+    unit_of_work: WriteSampleRecordUnitOfWork = Provide[
+        BotSampleRecordCommandContainer.rw_unit_of_work
     ],
+    record_use_cases_factory: Callable[
+        [ISampleRecordRepository], ISampleRecordUseCases
+    ] = Provider[BotSampleRecordCommandContainer.record_use_cases_factory],
 ) -> None:
     """Creates a sample record in the database."""
     handler = CreateSampleRecordHandler(
@@ -46,19 +46,21 @@ async def create_sample_record(
 
 
 @collector.command(**SampleRecordCommands.DELETE_RECORD.command_data())
-# @provide_session
 @inject
 async def delete_sample_record(
     message: IncomingMessage,
     bot: Bot,
-    session: AsyncSession,
-    record_use_cases_factory: Factory[ISampleRecordUseCases] = Provider[
-        BotSampleRecordCommandContainer.record_use_cases_factory
-    ],
+        unit_of_work: WriteSampleRecordUnitOfWork = Provide[
+            BotSampleRecordCommandContainer.rw_unit_of_work
+        ],
+        record_use_cases_factory: Callable[
+            [ISampleRecordRepository], ISampleRecordUseCases
+        ] = Provider[BotSampleRecordCommandContainer.record_use_cases_factory],
 ) -> None:
     """Delete a sample record in the database."""
     await DeleteSampleRecordHandler(
         bot=bot,
         message=message,
-        use_cases=record_use_cases_factory(session),
+        use_case_factory=record_use_cases_factory,
+        unit_of_work=unit_of_work,
     ).execute()

app/presentation/bot/middlewares/answer_error.py

@@ -19,6 +19,7 @@
 async def answer_error_middleware(
     message: IncomingMessage, bot: Bot, call_next: IncomingMessageHandlerFunc
 ) -> None:
+    """Middleware, used for catching and logging unhandled AnswerError and AnswerMessageError."""
     try:
         await call_next(message, bot)
     except AnswerError as exc:

tests/conftest.py

@@ -1,18 +1,10 @@
 import asyncio
 from datetime import datetime
-from typing import Any, Callable, Dict, Optional
-from uuid import UUID, uuid4
+from typing import Any, Dict
+from uuid import UUID
 
 import jwt
 import pytest
-from pybotx import (
-    BotAccount,
-    Chat,
-    ChatTypes,
-    IncomingMessage,
-    UserDevice,
-    UserSender,
-)
 from testcontainers.postgres import PostgresContainer  # type: ignore
 
 from app.settings import settings
@@ -72,54 +64,3 @@ def authorization_header(
     return {"authorization": f"Bearer {token}"}
 
 
-@pytest.fixture
-def incoming_message_factory(
-    bot_id: UUID,
-    user_huid: UUID,
-    host: str,
-) -> Callable[..., IncomingMessage]:
-    def factory(
-        *,
-        body: str = "",
-        ad_login: Optional[str] = None,
-        ad_domain: Optional[str] = None,
-    ) -> IncomingMessage:
-        return IncomingMessage(
-            bot=BotAccount(
-                id=bot_id,
-                host=host,
-            ),
-            sync_id=uuid4(),
-            source_sync_id=None,
-            body=body,
-            data={},
-            metadata={},
-            sender=UserSender(
-                huid=user_huid,
-                udid=None,
-                ad_login=ad_login,
-                ad_domain=ad_domain,
-                username=None,
-                is_chat_admin=True,
-                is_chat_creator=True,
-                device=UserDevice(
-                    manufacturer=None,
-                    device_name=None,
-                    os=None,
-                    pushes=None,
-                    timezone=None,
-                    permissions=None,
-                    platform=None,
-                    platform_package_id=None,
-                    app_version=None,
-                    locale=None,
-                ),
-            ),
-            chat=Chat(
-                id=uuid4(),
-                type=ChatTypes.PERSONAL_CHAT,
-            ),
-            raw_command=None,
-        )
-
-    return factory