feat: add tests command

src/infrastructure/database/repositories/user_repository.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from src.application.abstractions.repositories.i_user_repository import IUserRepository
+from src.application.contracts import ILogger
+from src.application.domain.entities.user import UserEntity
+from src.infrastructure.database.models.user import UserModel
+
+
+class UserRepository(IUserRepository):
+    def __init__(self,session:AsyncSession,logger:ILogger):
+        self._session=session
+        self._logger=logger
+
+
+    @staticmethod
+    def _to_entity(model:UserModel) -> UserEntity:
+        return UserEntity(
+            id=model.id,
+            email=model.email,
+            password_hash=model.password_hash,
+            first_name=model.first_name,
+            middle_name=model.middle_name,
+            last_name=model.last_name,
+            birth_date=model.birth_date,
+            crypto_wallet=model.crypto_wallet,
+            phone=model.phone,
+            bik=model.bik,
+            account_number=model.account_number,
+            card_number=model.card_number,
+            inn=model.inn,
+            kyc_verified=model.kyc_verified,
+            is_deleted=model.is_deleted,
+            created_at=model.created_at,
+            updated_at=model.updated_at,
+            kyc_verified_at=model.kyc_verified_at,
+        )
+
+
+    async def get(self,user_id:str) -> UserEntity|None:
+        stmt=(
+            select(UserModel)
+            .where(UserModel.id==user_id)
+            .where(UserModel.is_deleted.is_(False))
+        )
+        model=await self._session.scalar(stmt)
+        if model is None:
+            return None
+        return self._to_entity(model)

src/infrastructure/database/unit_of_work.py

@@ -1,10 +1,10 @@
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
 from src.application.abstractions import IUnitOfWork
-from src.application.abstractions.repositories import IOrderRepository,IPaymentRepository
+from src.application.abstractions.repositories import IOrderRepository,IPaymentRepository,IUserRepository
 from src.application.contracts import ILogger
 from src.infrastructure.database.repositories.order_repository import OrderRepository
 from src.infrastructure.database.repositories.payment_repository import PaymentRepository
-# from src.infrastructure.database.repositories import UserRepository, SessionRepository
+from src.infrastructure.database.repositories.user_repository import UserRepository
 
 
 
@@ -14,14 +14,14 @@ class UnitOfWork(IUnitOfWork):
         self._session: AsyncSession = None
         self._order_repository: IOrderRepository | None = None
         self._payment_repository: IPaymentRepository | None = None
-        # self._user_repository: IUserRepository = None
-        # self._session_repository: ISessionRepository = None
+        self._user_repository: IUserRepository | None = None
         self._logger: ILogger = logger
 
     async def __aenter__(self):
         self._session = self.session_factory()
         self._order_repository = None
         self._payment_repository = None
+        self._user_repository = None
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
@@ -48,14 +48,9 @@ class UnitOfWork(IUnitOfWork):
             self._payment_repository = PaymentRepository(session=self._session, logger=self._logger)
         return self._payment_repository
 
-    # @property
-    # def user_repository(self) -> IUserRepository:
-    #     if self._user_repository is None:
-    #         self._user_repository = UserRepository(session=self._session, logger=self._logger)
-    #     return self._user_repository
-    #
-    # @property
-    # def session_repository(self) -> ISessionRepository:
-    #     if self._session_repository is None:
-    #         self._session_repository = SessionRepository(session=self._session, logger=self._logger)
-    #     return self._session_repository
+
+    @property
+    def user_repository(self) -> IUserRepository:
+        if self._user_repository is None:
+            self._user_repository = UserRepository(session=self._session, logger=self._logger)
+        return self._user_repository