Merge pull request #28 from CodeHex16/settingsNelDb-lribon-sprint15

feat: storico chat limitato; closes #15 closes #21;

Author: bazz333

app/repositories/chat_repository.py

@@ -18,11 +18,16 @@ async def get_chat_by_user_email(self, user_email, limit=100):
             length=limit
         )
 
-    async def get_chat_by_id(self, chat_id, user_email):
-        return await self.collection.find_one(
+    async def get_chat_by_id(self, chat_id, user_email, limit: int = 0):
+        result = await self.collection.find_one(
             {"_id": ObjectId(chat_id), "user_email": user_email}
         )
 
+        if limit:
+            result["messages"] = result["messages"][-limit:]
+
+        return result
+
     async def initialize_chat(self, user_email):
         """Inizializza una nuova chat con il messaggio iniziale del bot"""
 

app/routes/chat.py

@@ -183,6 +183,7 @@ async def add_message_to_chat(
 @router.get("/{chat_id}/messages", response_model=schemas.ChatMessages)
 async def get_chat_messages(
     chat_id: str,
+    limit: int = None,
     current_user=Depends(verify_user),
     chat_repository=Depends(get_chat_repository),
 ):
@@ -191,6 +192,7 @@ async def get_chat_messages(
 
     ### Args:
     * **chat_id**: ID della chat di cui recuperare i messaggi.
+    * **limit**: Numero massimo di messaggi da recuperare (opzionale).
 
     ### Returns:
     * **result (ChatMessages)**: Nome della chat e lista dei messaggi contenuti in quella chat.
@@ -203,7 +205,7 @@ async def get_chat_messages(
     user_email = current_user.get("sub")
 
     # Verifica che la chat esista e appartenga all'utente
-    existing_chat = await chat_repository.get_chat_by_id(chat_id, user_email)
+    existing_chat = await chat_repository.get_chat_by_id(chat_id, user_email, limit)
     if not existing_chat:
         raise HTTPException(status_code=404, detail="Chat not found")
 

tests/routes/test_chat.py

@@ -2,20 +2,22 @@
 from unittest.mock import MagicMock, AsyncMock, patch
 from fastapi import APIRouter, Depends, HTTPException, status
 import app.schemas as schemas
+
 # updateresult
 from pymongo.results import UpdateResult
 
 from app.routes.chat import (
-  get_new_chat,
-  get_chats,
-  change_chat_name,
-  delete_chat,
-  add_message_to_chat,
-  get_chat_messages,
-  rate_message
+    get_new_chat,
+    get_chats,
+    change_chat_name,
+    delete_chat,
+    add_message_to_chat,
+    get_chat_messages,
+    rate_message,
 )
 from bson import ObjectId
 
+
 @pytest.fixture
 def fake_chat_repo():
     class FakeChatRepository:
@@ -26,26 +28,41 @@ async def initialize_chat(self, user_email):
                 "user_email": user_email,
                 "messages": [],
             }
+
         async def get_chat_by_user_email(self, user_email):
             if user_email == "hi@hi.com":
                 return [
-                    {"_id": "chat123", "name": "Test Chat", "user_email": user_email, "messages": []},
-                    {"_id": "chat456", "name": "Test Chat 456", "user_email": user_email, "messages": []}
-                    ]
-        async def get_chat_by_id(self, chat_id, user_email):
-            print(chat_id, user_email)
-            if chat_id == "chat123" or chat_id == b'foo-bar-quux':
+                    {
+                        "_id": "chat123",
+                        "name": "Test Chat",
+                        "user_email": user_email,
+                        "messages": [],
+                    },
+                    {
+                        "_id": "chat456",
+                        "name": "Test Chat 456",
+                        "user_email": user_email,
+                        "messages": [],
+                    },
+                ]
+
+        async def get_chat_by_id(self, chat_id, user_email, limit=None):
+            print(chat_id, user_email, limit)
+            if chat_id == "chat123" or chat_id == b"foo-bar-quux":
                 return {
-                    "_id": 'foo-bar-quux',
+                    "_id": "foo-bar-quux",
                     "name": "Test Chat",
                     "user_email": user_email,
                     "messages": [],
                 }
             return None
+
         async def update_chat(self, chat_id, chat_data):
             return 1
+
         async def delete_chat(self, chat_id, user_email):
             return 1
+
         async def add_message(self, chat_id, message: schemas.MessageCreate):
             return {
                 "_id": "message123",
@@ -54,170 +71,202 @@ async def add_message(self, chat_id, message: schemas.MessageCreate):
                 "timestamp": "2023-10-01T00:00:00Z",
                 "rating": None,
             }
-        async def update_message_rating(self, chat_id, message_id: ObjectId, rating_data):
+
+        async def update_message_rating(
+            self, chat_id, message_id: ObjectId, rating_data
+        ):
 
             MockUpdateResult = MagicMock()
             if str(message_id) == "614c1b2f8e4b0c6a1d2d5d2f":
                 MockUpdateResult.matched_count = 1
                 MockUpdateResult.modified_count = 1
                 return MockUpdateResult
-            if str(message_id) == '614c1b2f8e4b0c6a1d2d5d21':
+            if str(message_id) == "614c1b2f8e4b0c6a1d2d5d21":
                 MockUpdateResult.matched_count = 1
                 MockUpdateResult.modified_count = 0
                 return MockUpdateResult
-            if str(message_id) == '614c1b2f8e4b0c6a1d2d5d29':
+            if str(message_id) == "614c1b2f8e4b0c6a1d2d5d29":
                 MockUpdateResult.matched_count = 0
                 MockUpdateResult.modified_count = 0
                 return MockUpdateResult
-            if str(message_id) == '614c1b2f8e4b0c6a1d2d5d25':
+            if str(message_id) == "614c1b2f8e4b0c6a1d2d5d25":
                 raise HTTPException(status_code=500, detail="Internal Server Error")
-            if str(message_id) == '614c1b2f8e4b0c6a1d2d5d26':
+            if str(message_id) == "614c1b2f8e4b0c6a1d2d5d26":
                 raise Exception(status_code=504, detail="Internal Server Error")
+
     return FakeChatRepository()
-        
+
+
 @pytest.mark.asyncio
 async def test__unit_test__get_new_chat(fake_chat_repo):
-    current_user = {"sub":"hi@hi.com"}
+    current_user = {"sub": "hi@hi.com"}
     chat = await get_new_chat(current_user, fake_chat_repo)
     assert chat["chat_id"] == "chat123"
 
+
 @pytest.mark.asyncio
 async def test__unit_test__get_new_chat_no_email(fake_chat_repo):
-    current_user = {"sub":""}
+    current_user = {"sub": ""}
     with pytest.raises(HTTPException) as excinfo:
         await get_new_chat(current_user, fake_chat_repo)
     assert excinfo.value.status_code == 400
 
+
 @pytest.mark.asyncio
 async def test__unit_test__get_new_chat_no_chat(fake_chat_repo):
-    current_user = {"sub":"hi@hi.com"}
+    current_user = {"sub": "hi@hi.com"}
     chat = await get_chats(current_user, fake_chat_repo)
     assert chat[0]["id"] == "chat123"
 
+
 @pytest.mark.asyncio
 async def test__unit_test__get_new_chat_no_chat_no_email(fake_chat_repo):
-    current_user = {"sub":""}
+    current_user = {"sub": ""}
     with pytest.raises(HTTPException) as excinfo:
         await get_chats(current_user, fake_chat_repo)
     assert excinfo.value.status_code == 400
 
+
 @pytest.mark.asyncio
 async def test__unit_test__change_chat_name(fake_chat_repo):
-    current_user = {"sub":"hi@hi.com"}
+    current_user = {"sub": "hi@hi.com"}
     chat_id = "chat123"
     await change_chat_name(chat_id, "New Chat Name", current_user, fake_chat_repo)
-    
+
+
 @pytest.mark.asyncio
 async def test__unit_test__change_chat_name_not_found(fake_chat_repo):
-    current_user = {"sub":"hi@hi.com"}
+    current_user = {"sub": "hi@hi.com"}
     chat_id = "chat124"
     with pytest.raises(HTTPException) as excinfo:
         await change_chat_name(chat_id, "New Chat Name", current_user, fake_chat_repo)
     assert excinfo.value.status_code == 404
-     
+
+
 @pytest.mark.asyncio
 async def test__unit_test__delete_chat(fake_chat_repo):
-    current_user = {"sub":"hi@hi.com"}
+    current_user = {"sub": "hi@hi.com"}
     chat_id = "chat123"
     await delete_chat(chat_id, current_user, fake_chat_repo)
 
+
 @pytest.mark.asyncio
 async def test__unit_test__delete_chat_not_found(fake_chat_repo):
-    current_user = {"sub":"hi@hi.com"}
+    current_user = {"sub": "hi@hi.com"}
     chat_id = "chat124"
     with pytest.raises(HTTPException) as excinfo:
         await delete_chat(chat_id, current_user, fake_chat_repo)
     assert excinfo.value.status_code == 404
-                    
+
+
 @pytest.mark.asyncio
 async def test__unit_test__add_message_to_chat(fake_chat_repo):
-    current_user = {"sub":"hi@hi.com"}
+    current_user = {"sub": "hi@hi.com"}
     chat_id = "chat123"
     message = schemas.MessageCreate(content="Hello!", sender="user")
-    result = await add_message_to_chat(chat_id, message, current_user, fake_chat_repo) 
+    result = await add_message_to_chat(chat_id, message, current_user, fake_chat_repo)
     assert result["_id"] == "message123"
 
+
 @pytest.mark.asyncio
 async def test__unit_test__add_message_to_chat_not_found(fake_chat_repo):
-    current_user = {"sub":"hi@hi.com"}
+    current_user = {"sub": "hi@hi.com"}
     chat_id = "chat124"
     message = schemas.MessageCreate(content="Hello!", sender="user")
     with pytest.raises(HTTPException) as excinfo:
         await add_message_to_chat(chat_id, message, current_user, fake_chat_repo)
     assert excinfo.value.status_code == 404
 
+
 @pytest.mark.asyncio
 async def test__unit_test__get_chat_messages(fake_chat_repo):
-    current_user = {"sub":"hi@hi.com"}
+    current_user = {"sub": "hi@hi.com"}
     chat_id = "chat123"
-    messages = await get_chat_messages(chat_id, current_user, fake_chat_repo)
+    messages = await get_chat_messages(chat_id, None, current_user, fake_chat_repo)
     assert messages["messages"] == []
 
+
 @pytest.mark.asyncio
 async def test__unit_test__get_chat_messages_not_found(fake_chat_repo):
-    current_user = {"sub":"hi@hi.com"}
+    current_user = {"sub": "hi@hi.com"}
     chat_id = "chat125"
     with pytest.raises(HTTPException) as excinfo:
-        await get_chat_messages(chat_id, current_user, fake_chat_repo)
+        await get_chat_messages(chat_id, None, current_user, fake_chat_repo)
     assert excinfo.value.status_code == 404
 
+
 @pytest.mark.asyncio
 async def test__unit_test__rate_message(fake_chat_repo):
-    current_user = {"sub":"hi@hi.com"}
-    chat_id = b'foo-bar-quux'
+    current_user = {"sub": "hi@hi.com"}
+    chat_id = b"foo-bar-quux"
     message_id = "614c1b2f8e4b0c6a1d2d5d2f"
     rating_data = schemas.MessageRatingUpdate(rating=True)
 
-    result = await rate_message(chat_id, message_id, rating_data, current_user, fake_chat_repo)
+    result = await rate_message(
+        chat_id, message_id, rating_data, current_user, fake_chat_repo
+    )
+
 
 @pytest.mark.asyncio
 async def test__unit_test__rate_message_no_chat(fake_chat_repo):
-    current_user = {"sub":"hi@hi.com"}
-    chat_id = b'foo-bar-quuu'
+    current_user = {"sub": "hi@hi.com"}
+    chat_id = b"foo-bar-quuu"
     message_id = "614c1b2f8e4b0c6a1d2d5d2f"
     rating_data = schemas.MessageRatingUpdate(rating=True)
     with pytest.raises(HTTPException) as excinfo:
-        await rate_message(chat_id, message_id, rating_data, current_user, fake_chat_repo)
+        await rate_message(
+            chat_id, message_id, rating_data, current_user, fake_chat_repo
+        )
     assert excinfo.value.status_code == 404
 
+
 @pytest.mark.asyncio
 async def test__unit_test__rate_message_no_message(fake_chat_repo):
-    current_user = {"sub":"hi@hi.com"}
-    chat_id = b'foo-bar-quux'
+    current_user = {"sub": "hi@hi.com"}
+    chat_id = b"foo-bar-quux"
     message_id = "614c1b2f8e4b0c6a1d2d5d29"
     rating_data = schemas.MessageRatingUpdate(rating=True)
     with pytest.raises(HTTPException) as excinfo:
-        await rate_message(chat_id, message_id, rating_data, current_user, fake_chat_repo)
+        await rate_message(
+            chat_id, message_id, rating_data, current_user, fake_chat_repo
+        )
     assert excinfo.value.status_code == 404
 
+
 @pytest.mark.asyncio
 async def test__unit_test__rate_message_no_edit(fake_chat_repo):
-    current_user = {"sub":"hi@hi.com"}
-    chat_id = b'foo-bar-quux'
+    current_user = {"sub": "hi@hi.com"}
+    chat_id = b"foo-bar-quux"
     message_id = "614c1b2f8e4b0c6a1d2d5d21"
     rating_data = schemas.MessageRatingUpdate(rating=True)
     with pytest.raises(HTTPException) as excinfo:
-        await rate_message(chat_id, message_id, rating_data, current_user, fake_chat_repo)
+        await rate_message(
+            chat_id, message_id, rating_data, current_user, fake_chat_repo
+        )
     assert excinfo.value.status_code == 304
 
+
 @pytest.mark.asyncio
 async def test__unit_test__rate_message_internal_error(fake_chat_repo):
-    current_user = {"sub":"hi@hi.com"}
-    chat_id = b'foo-bar-quux'
+    current_user = {"sub": "hi@hi.com"}
+    chat_id = b"foo-bar-quux"
     message_id = "614c1b2f8e4b0c6a1d2d5d25"
     rating_data = schemas.MessageRatingUpdate(rating=True)
     with pytest.raises(HTTPException) as excinfo:
-        await rate_message(chat_id, message_id, rating_data, current_user, fake_chat_repo)
+        await rate_message(
+            chat_id, message_id, rating_data, current_user, fake_chat_repo
+        )
     assert excinfo.value.status_code == 500
 
+
 @pytest.mark.asyncio
 async def test__unit_test__rate_message_internal_error_2(fake_chat_repo):
-    current_user = {"sub":"hi@hi.com"}
-    chat_id = b'foo-bar-quux'
+    current_user = {"sub": "hi@hi.com"}
+    chat_id = b"foo-bar-quux"
     message_id = "614c1b2f8e4b0c6a1d2d5d26"
     rating_data = schemas.MessageRatingUpdate(rating=True)
     with pytest.raises(HTTPException) as excinfo:
-        await rate_message(chat_id, message_id, rating_data, current_user, fake_chat_repo)
+        await rate_message(
+            chat_id, message_id, rating_data, current_user, fake_chat_repo
+        )
     assert excinfo.value.status_code == 500
-
-