Added Async Operations for the model travel_diary_service_mock.py and service_manager_mock.py and added a call to main in the command.py

src/pilgrim/command.py

@@ -4,3 +4,6 @@ from pilgrim.application import Application
 def main():
     app = Application()
     app.run()
+
+if __name__ == "__main__":
+    main()

src/pilgrim/service/mocks/service_manager_mock.py

@@ -8,12 +8,16 @@ from pilgrim.service.servicemanager import ServiceManager
 class ServiceManagerMock(ServiceManager):
     def __init__(self):
         super().__init__()
+        # Cria instâncias únicas para manter estado consistente
+        self._travel_diary_service = TravelDiaryServiceMock()
+        self._entry_service = EntryServiceMock()
+        self._photo_service = PhotoServiceMock()
 
     def get_entry_service(self):
-        return EntryServiceMock()
+        return self._entry_service
 
     def get_travel_diary_service(self):
-        return TravelDiaryServiceMock()
+        return self._travel_diary_service
 
     def get_photo_service(self):
-        return PhotoServiceMock()
+        return self._photo_service

src/pilgrim/service/mocks/travel_diary_service_mock.py

@@ -1,34 +1,67 @@
 from pilgrim.service.travel_diary_service import TravelDiaryService
 from pilgrim.models.travel_diary import TravelDiary
+import asyncio
 
 
 class TravelDiaryServiceMock(TravelDiaryService):
     def __init__(self):
         super().__init__(None)
         self.mock_data = {
-            1:TravelDiary(id=1,name="Montreal"),
+            1: TravelDiary(id=1, name="Montreal"),
-            2:TravelDiary(id=2,name="Rio de Janeiro"),
+            2: TravelDiary(id=2, name="Rio de Janeiro"),
         }
         self._next_id = 3
 
+    # Métodos síncronos (originais)
     def create(self, name: str):
-        new_travel_diary = TravelDiary(id=self._next_id,name=name)
+        """Versão síncrona"""
+        new_travel_diary = TravelDiary(id=self._next_id, name=name)
         self.mock_data[self._next_id] = new_travel_diary
         self._next_id += 1
         return new_travel_diary
 
     def read_by_id(self, travel_id: int):
-        return self.mock_data[travel_id]
+        """Versão síncrona"""
+        return self.mock_data.get(travel_id)
 
     def read_all(self):
+        """Versão síncrona"""
         return list(self.mock_data.values())
 
-    def update(self, travel_diary_id: int, travel_diary_dst: TravelDiary):
+    def update(self, travel_diary_id: int, name: str):
+        """Versão síncrona"""
         item_to_update = self.mock_data.get(travel_diary_id)
         if item_to_update:
-            item_to_update.name = travel_diary_dst.name if travel_diary_dst.name is not None else item_to_update.name
+            item_to_update.name = name
             return item_to_update
         return None
 
     def delete(self, travel_diary_id: int):
+        """Versão síncrona"""
         return self.mock_data.pop(travel_diary_id, None)
+
+    # Métodos assíncronos (novos)
+    async def async_create(self, name: str):
+        """Versão assíncrona"""
+        await asyncio.sleep(0.01)  # Simula I/O
+        return self.create(name)
+
+    async def async_read_by_id(self, travel_id: int):
+        """Versão assíncrona"""
+        await asyncio.sleep(0.01)  # Simula I/O
+        return self.read_by_id(travel_id)
+
+    async def async_read_all(self):
+        """Versão assíncrona"""
+        await asyncio.sleep(0.01)  # Simula I/O
+        return self.read_all()
+
+    async def async_update(self, travel_diary_id: int, name: str):
+        """Versão assíncrona"""
+        await asyncio.sleep(0.01)  # Simula I/O
+        return self.update(travel_diary_id, name)
+
+    async def async_delete(self, travel_diary_id: int):
+        """Versão assíncrona"""
+        await asyncio.sleep(0.01)  # Simula I/O
+        return self.delete(travel_diary_id)