test: Add test methods in user_service test class

Author: cevheri

app/service/email_service.py

@@ -52,5 +52,8 @@ async def send_email(to, subject: str, body: str, attachment_path: str | None =
         log.info(f"Send email to {to} successfully, From: {username} {attachment_message}")
     except Exception as e:
         log.error(f"Failed to send email to {to}, Error: {e}")
+        return False
     finally:
         server.quit()
+
+    return True

app/service/user_service.py

@@ -17,24 +17,6 @@
 _log = logging.getLogger(__name__)
 
 
-async def send_creation_email(user: UserDTO):
-    """
-    Send creation email to user with background task
-    :param user: created user information
-    """
-    _log.debug(f"UserService Sending creation email on background task to user: {user.email}")
-    to = user.email
-    app_name = app_settings.APP_NAME
-    app_url = app_settings.APP_URL
-    subject = f"Welcome to the {app_name}"
-    body = f"Hello {user.first_name},\n\n" \
-           f"Welcome to the {app_name}. Your account has been created successfully.\n\n" \
-           f"Please visit {app_url} to login to your account.\n\n" \
-           f"{app_name} Team."
-    await email_service.send_email(to, subject, body)
-    _log.debug(f"UserService Creation email sent to user: {user.email}")
-
-
 class UserService:
     """
     User Business Logic Service that is responsible for handling business logic for User entity operations.
@@ -48,6 +30,7 @@ class UserService:
     def __init__(self, user_repository: UserRepository = Depends()):
         _log.info("UserService Initializing")
         self.repository = user_repository
+        self.email_service = email_service
 
     async def user_create_validation(self, user_create: UserCreate):
         """
@@ -63,6 +46,26 @@ async def user_create_validation(self, user_create: UserCreate):
             raise BusinessException(ErrorCodes.ALREADY_EXISTS,
                                     f"User with email already exists: {user_create.email}")
 
+    async def send_creation_email(self, user: UserDTO):
+        """
+        Send creation email to user with background task
+        :param user: created user information
+        """
+        _log.debug(f"Sending creation email on background task")
+        if user is None:
+            raise BusinessException(ErrorCodes.NOT_FOUND, "User not found")
+
+        to = user.email
+        app_name = app_settings.APP_NAME
+        app_url = app_settings.APP_URL
+        subject = f"Welcome to the {app_name}"
+        body = f"Hello {user.first_name},\n\n" \
+               f"Welcome to the {app_name}. Your account has been created successfully.\n\n" \
+               f"Please visit {app_url} to login to your account.\n\n" \
+               f"{app_name} Team."
+        await self.email_service.send_email(to, subject, body)
+        _log.debug(f"Sent Creation email sent to user: {user.email}")
+
     async def create(self, user_create: UserCreate, token_data: JWTUser) -> UserDTO:
         _log.debug(f"UserService Creating user: {user_create} with: {type(user_create)}")
 
@@ -83,7 +86,7 @@ async def create(self, user_create: UserCreate, token_data: JWTUser) -> UserDTO:
 
         _log.debug(f"UserService User created: {result.user_id}")
         try:
-            await send_creation_email(result)
+            await self.send_creation_email(result)
         except Exception as e:
             _log.error(f"UserService Error sending creation email: {e}")
         return result

test/repository/test_user_repository.py

@@ -111,10 +111,18 @@ class TestUserRepository(unittest.IsolatedAsyncioTestCase):
       """
 
     def __init__(self, *args, **kwargs):
+        """
+        Initializes the TestUserRepository class.
+        :param args: arguments
+        :param kwargs:  keyword arguments
+        """
         _log.info("Initializing TestUserRepository")
         super(TestUserRepository, self).__init__(*args, **kwargs)
 
     async def asyncSetUp(self):
+        """
+        Sets up the resources required for the tests.
+        """
         _log.info("Setting up each resources.")
         self.container = MongoDbContainer(image="mongo:latest")
         self.container.start()
@@ -124,6 +132,9 @@ async def asyncSetUp(self):
         await init_beanie(document_models=entities, database=self.db)
 
     async def asyncTearDown(self):
+        """
+        Tears down the resources after the tests.
+        """
         _log.info("Tearing down each resources.")
         await self.db.get_collection(_collection_name).delete_many({})
         self.client.close()
@@ -132,6 +143,9 @@ async def asyncTearDown(self):
     # region create entity tests
     @pytest.mark.asyncio
     async def test_given_min_entity_when_insert_then_successfully_created(self):
+        """
+        Test case to create a user entity with minimal data and verify the creation process.
+        """
         _log.info("test_given_min_entity_when_insert_then_successfully_created")
         # Given
         entity = _get_min_entity()
@@ -157,6 +171,9 @@ async def test_given_min_entity_when_insert_then_successfully_created(self):
 
     @pytest.mark.asyncio
     async def test_given_full_entity_when_insert_then_successfully_created(self):
+        """
+        Test case to create a user entity with full data and verify the creation process.
+        """
         _log.info("test_given_full_entity_when_insert_then_successfully_created")
 
         # Given
@@ -183,6 +200,9 @@ async def test_given_full_entity_when_insert_then_successfully_created(self):
 
     @pytest.mark.asyncio
     async def test_given_invalid_entity_when_insert_then_fail(self):
+        """
+        Test case to handle invalid user entity creation attempts.
+        """
         _log.info("test_given_invalid_entity_when_insert_then_fail")
 
         # Given
@@ -199,6 +219,9 @@ async def test_given_invalid_entity_when_insert_then_fail(self):
     # region update entity tests
     @pytest.mark.asyncio
     async def test_given_entity_when_update_then_successfully_updated(self):
+        """
+        Test case to update a user entity and verify the changes are correctly applied.
+        """
         _log.info("test_given_entity_when_update_then_successfully_updated")
 
         # Given
@@ -236,6 +259,9 @@ async def test_given_entity_when_update_then_successfully_updated(self):
 
     @pytest.mark.asyncio
     async def test_given_invalid_userid_when_update_then_fail(self):
+        """
+        Test case to handle invalid user ID during update attempts.
+        """
         _log.info("test_given_invalid_entity_when_update_then_fail")
 
         # inti entity
@@ -251,6 +277,9 @@ async def test_given_invalid_userid_when_update_then_fail(self):
 
     @pytest.mark.asyncio
     async def test_given_invalid_username_when_update_then_fail(self):
+        """
+        Test case to handle invalid username during update attempts.
+        """
         _log.info("test_given_invalid_entity_when_update_then_fail")
 
         # inti entity
@@ -266,6 +295,9 @@ async def test_given_invalid_username_when_update_then_fail(self):
 
     @pytest.mark.asyncio
     async def test_given_invalid_email_when_update_then_fail(self):
+        """
+        Test case to handle invalid email during update attempts.
+        """
         _log.info("test_given_invalid_entity_when_update_then_fail")
 
         # inti entity
@@ -291,6 +323,9 @@ async def test_given_invalid_email_when_update_then_fail(self):
 
     @pytest.mark.asyncio
     async def test_given_deleted_entity_when_retrieve_then_should_fail(self):
+        """
+        Test case to handle deleted user entity retrieval attempts.
+        """
         _log.info("test_given_entity_when_delete_then_successfully_deleted")
 
         # Given
@@ -309,6 +344,9 @@ async def test_given_deleted_entity_when_retrieve_then_should_fail(self):
 
     @pytest.mark.asyncio
     async def test_given_random_id_when_delete_then_should_fail(self):
+        """
+        Test case to handle deletion attempts for non-existent user entities.
+        """
         _log.info("test_given_entity_when_delete_then_successfully_deleted")
 
         repository = _get_repo()
@@ -327,6 +365,9 @@ async def test_given_random_id_when_delete_then_should_fail(self):
     # success case with default values
     @pytest.mark.asyncio
     async def test_given_entity_when_find_then_success(self):
+        """
+        Test case to find user entities and verify the results.
+        """
         _log.info("test_given_entity_when_find_then_success")
 
         # Given
@@ -346,6 +387,9 @@ async def test_given_entity_when_find_then_success(self):
     # success case with mongodb query
     @pytest.mark.asyncio
     async def test_given_native_mogo_query_when_find_with_query_then_success(self):
+        """
+        Test case to find user entities with a MongoDB query and verify the results.
+        """
         _log.info("test_given_entity_when_find_with_query_then_success")
 
         # Given
@@ -365,6 +409,9 @@ async def test_given_native_mogo_query_when_find_with_query_then_success(self):
     # success case with query, page, size, sort
     @pytest.mark.asyncio
     async def test_given_native_mogo_query_when_find_with_query_page_size_sort_then_success(self):
+        """
+        Test case to find user entities with a MongoDB query, pagination, and sorting, and verify the results.
+        """
         _log.info("test_given_entity_when_find_with_query_page_size_sort_then_success")
 
         # Given
@@ -384,6 +431,9 @@ async def test_given_native_mogo_query_when_find_with_query_page_size_sort_then_
     # success case with dict convert to query, page, size, sort
     @pytest.mark.asyncio
     async def test_given_dict_when_find_with_query_then_success(self):
+        """
+        Test case to find user entities with a dictionary query, pagination, and sorting, and verify the results.
+        """
         _log.info("test_given_entity_when_find_with_invalid_query_then_fail")
 
         # Given
@@ -405,6 +455,9 @@ async def test_given_dict_when_find_with_query_then_success(self):
     # fail case with invalid query
     @pytest.mark.asyncio
     async def test_given_invalid_query_when_find_with_invalid_query_then_fail(self):
+        """
+        Test case to handle invalid query attempts during user entity retrieval.
+        """
         _log.info("test_given_entity_when_find_with_invalid_query_then_fail")
 
         # Given
@@ -422,6 +475,9 @@ async def test_given_invalid_query_when_find_with_invalid_query_then_fail(self):
     # success case with count
     @pytest.mark.asyncio
     async def test_given_entity_when_count_then_success(self):
+        """
+        Test case to count user entities and verify the results.
+        """
         _log.info("test_given_entity_when_count_then_success")
 
         # Given
@@ -440,6 +496,9 @@ async def test_given_entity_when_count_then_success(self):
     # fail case with count
     @pytest.mark.asyncio
     async def test_given_invalid_query_when_count_with_invalid_query_then_fail(self):
+        """
+        Test case to handle invalid query attempts during user entity count.
+        """
         _log.info("test_given_entity_when_count_with_invalid_query_then_fail")
 
         # Given
@@ -457,6 +516,9 @@ async def test_given_invalid_query_when_count_with_invalid_query_then_fail(self)
     # success case with valid  user_id retrieve
     @pytest.mark.asyncio
     async def test_given_entity_when_retrieve_then_success(self):
+        """
+        Test case to retrieve a user entity by user ID and verify the results.
+        """
         _log.info("test_given_entity_when_retrieve_then_success")
 
         # Given
@@ -479,6 +541,9 @@ async def test_given_entity_when_retrieve_then_success(self):
     # fail case with invalid user_id retrieve
     @pytest.mark.asyncio
     async def test_given_invalid_user_id_when_retrieve_then_fail(self):
+        """
+        Test case to handle invalid user ID during user entity retrieval.
+        """
         _log.info("test_given_invalid_user_id_when_retrieve_then_fail")
 
         # Given
@@ -494,6 +559,9 @@ async def test_given_invalid_user_id_when_retrieve_then_fail(self):
     # success case with valid email retrieve_by_email
     @pytest.mark.asyncio
     async def test_given_entity_when_retrieve_by_email_then_success(self):
+        """
+        Test case to retrieve a user entity by email and verify the results.
+        """
         _log.info("test_given_entity_when_retrieve_by_email_then_success")
 
         # Given
@@ -516,6 +584,9 @@ async def test_given_entity_when_retrieve_by_email_then_success(self):
     # fail case with invalid email retrieve_by_email
     @pytest.mark.asyncio
     async def test_given_invalid_email_when_retrieve_by_email_then_fail(self):
+        """
+        Test case to handle invalid email during user entity retrieval by email.
+        """
         _log.info("test_given_invalid_email_when_retrieve_by_email_then_fail")
 
         # Given
@@ -531,6 +602,9 @@ async def test_given_invalid_email_when_retrieve_by_email_then_fail(self):
     # success case with valid username retrieve_by_username
     @pytest.mark.asyncio
     async def test_given_entity_when_retrieve_by_username_then_success(self):
+        """
+        Test case to retrieve a user entity by username and verify the results.
+        """
         _log.info("test_given_entity_when_retrieve_by_username_then_success")
 
         # Given
@@ -553,6 +627,9 @@ async def test_given_entity_when_retrieve_by_username_then_success(self):
     # fail case with invalid username retrieve_by_username
     @pytest.mark.asyncio
     async def test_given_invalid_username_when_retrieve_by_username_then_fail(self):
+        """
+        Test case to handle invalid username during user entity retrieval by username.
+        """
         _log.info("test_given_invalid_username_when_retrieve_by_username_then_fail")
 
         # Given