Merge pre-existing with newly added tests, solves Chainlit#1137.

Author: dokterbob

backend/chainlit/data/sql_alchemy.py

@@ -122,7 +122,23 @@ async def get_user(self, identifier: str) -> Optional[PersistedUser]:
         result = await self.execute_sql(query=query, parameters=parameters)
         if result and isinstance(result, list):
             user_data = result[0]
-            return PersistedUser(**user_data)
+
+            # SQLite returns JSON as string, we most convert it. (#1137)
+            metadata = user_data.get("metadata", {})
+            if isinstance(metadata, str):
+                metadata = json.loads(metadata)
+
+            assert isinstance(metadata, dict)
+            assert isinstance(user_data["id"], str)
+            assert isinstance(user_data["identifier"], str)
+            assert isinstance(user_data["createdAt"], str)
+
+            return PersistedUser(
+                id=user_data["id"],
+                identifier=user_data["identifier"],
+                createdAt=user_data["createdAt"],
+                metadata=metadata,
+            )
         return None
 
     async def create_user(self, user: User) -> Optional[PersistedUser]:
@@ -377,12 +393,18 @@ async def delete_feedback(self, feedback_id: str) -> bool:
         return True
 
     ###### Elements ######
-    async def get_element(self, thread_id: str, element_id: str) -> Optional["ElementDict"]:
+    async def get_element(
+        self, thread_id: str, element_id: str
+    ) -> Optional["ElementDict"]:
         if self.show_logger:
-            logger.info(f"SQLAlchemy: get_element, thread_id={thread_id}, element_id={element_id}")
+            logger.info(
+                f"SQLAlchemy: get_element, thread_id={thread_id}, element_id={element_id}"
+            )
         query = """SELECT * FROM elements WHERE "threadId" = :thread_id AND "id" = :element_id"""
         parameters = {"thread_id": thread_id, "element_id": element_id}
-        element: Union[List[Dict[str, Any]], int, None] = await self.execute_sql(query=query, parameters=parameters)
+        element: Union[List[Dict[str, Any]], int, None] = await self.execute_sql(
+            query=query, parameters=parameters
+        )
         if isinstance(element, list) and element:
             element_dict: Dict[str, Any] = element[0]
             return ElementDict(
@@ -400,7 +422,7 @@ async def get_element(self, thread_id: str, element_id: str) -> Optional["Elemen
                 autoPlay=element_dict.get("autoPlay"),
                 playerConfig=element_dict.get("playerConfig"),
                 forId=element_dict.get("forId"),
-                mime=element_dict.get("mime")
+                mime=element_dict.get("mime"),
             )
         else:
             return None
@@ -611,7 +633,8 @@ async def get_all_user_threads(
                         tags=step_feedback.get("step_tags"),
                         input=(
                             step_feedback.get("step_input", "")
-                            if step_feedback.get("step_showinput") not in [None, "false"]
+                            if step_feedback.get("step_showinput")
+                            not in [None, "false"]
                             else None
                         ),
                         output=step_feedback.get("step_output", ""),

backend/chainlit/data/suites/__init__.py

@@ -9,23 +9,32 @@
 from chainlit.user_session import UserSession
 
 
-@asynccontextmanager
-async def create_chainlit_context():
-    mock_session = Mock(spec=WebsocketSession)
-    mock_session.id = "test_session_id"
-    mock_session.user_env = {"test_env": "value"}
-    mock_session.chat_settings = {}
-    mock_user = Mock(spec=PersistedUser)
-    mock_user.id = "test_user_id"
-    mock_session.user = mock_user
-    mock_session.chat_profile = None
-    mock_session.http_referer = None
-    mock_session.client_type = "webapp"
-    mock_session.languages = ["en"]
-    mock_session.thread_id = "test_thread_id"
-    mock_session.emit = AsyncMock()
-    mock_session.has_first_interaction = True
+@pytest.fixture
+def mock_persisted_user():
+    mock = Mock(spec=PersistedUser)
+    mock.id = "test_user_id"
+    return mock
+
+
+@pytest.fixture
+def mock_session():
+    mock = Mock(spec=WebsocketSession)
+    mock.id = "test_session_id"
+    mock.user_env = {"test_env": "value"}
+    mock.chat_settings = {}
+    mock.chat_profile = None
+    mock.http_referer = None
+    mock.client_type = "webapp"
+    mock.languages = ["en"]
+    mock.thread_id = "test_thread_id"
+    mock.emit = AsyncMock()
+    mock.has_first_interaction = True
+
+    return mock
 
+
+@asynccontextmanager
+async def create_chainlit_context(mock_session):
     context = ChainlitContext(mock_session)
     token = context_var.set(context)
     try:
@@ -35,8 +44,9 @@ async def create_chainlit_context():
 
 
 @pytest_asyncio.fixture
-async def mock_chainlit_context():
-    return create_chainlit_context()
+async def mock_chainlit_context(mock_persisted_user, mock_session):
+    mock_session.user = mock_persisted_user
+    return create_chainlit_context(mock_session)
 
 
 @pytest.fixture

backend/chainlit/data/suites/checks_suites.py

@@ -1,14 +1,17 @@
+from unittest.mock import Mock
 import uuid
 from pathlib import Path
 
 import pytest
-
+import pytest_asyncio
 from sqlalchemy.ext.asyncio import create_async_engine
 from sqlalchemy import text
 
-from chainlit.data.base import BaseStorageClient
+from chainlit.data.base import BaseDataLayer, BaseStorageClient
 from chainlit.data.sql_alchemy import SQLAlchemyDataLayer
 from chainlit.element import Text
+from chainlit import User
+from chainlit.user import PersistedUser
 
 
 @pytest.fixture
@@ -113,7 +116,11 @@ async def data_layer(mock_storage_client: BaseStorageClient, tmp_path: Path):
     yield data_layer
 
 
-@pytest.mark.asyncio
+@pytest.fixture
+def test_user() -> User:
+    return User(identifier="test_user_id", metadata={"test": 1})
+
+
 async def test_create_and_get_element(
     mock_chainlit_context, data_layer: SQLAlchemyDataLayer
 ):
@@ -136,3 +143,79 @@ async def test_create_and_get_element(
         assert retrieved_element["name"] == text_element.name
         assert retrieved_element["mime"] == text_element.mime
         # The 'content' field is not part of the ElementDict, so we remove this assertion
+
+
+async def test_get_current_timestamp(
+    mock_chainlit_context, data_layer: SQLAlchemyDataLayer
+):
+    async with mock_chainlit_context:
+        timestamp = await data_layer.get_current_timestamp()
+    assert isinstance(timestamp, str)
+
+
+async def test_get_user(
+    mock_chainlit_context, test_user: User, data_layer: SQLAlchemyDataLayer
+):
+    async with mock_chainlit_context:
+        result = await data_layer.get_user(test_user.identifier)
+    assert result is None
+
+
+async def test_create_user(
+    mock_chainlit_context, test_user: User, data_layer: SQLAlchemyDataLayer
+):
+    async with mock_chainlit_context:
+        persisted_user = await data_layer.create_user(test_user)
+
+    assert persisted_user
+    assert persisted_user.identifier == test_user.identifier
+    assert persisted_user.id
+    assert persisted_user.createdAt
+
+
+async def test_get_thread_author(
+    mock_chainlit_context, test_user: User, data_layer: SQLAlchemyDataLayer
+):
+    async with mock_chainlit_context:
+        persisted_user = await data_layer.create_user(test_user)
+        assert persisted_user
+
+        await data_layer.update_thread("test_thread", persisted_user.identifier)
+        author = await data_layer.get_thread_author("test_thread")
+    assert author == persisted_user.identifier
+
+
+async def test_get_thread(
+    mock_chainlit_context, test_user: User, data_layer: SQLAlchemyDataLayer
+):
+    async with mock_chainlit_context:
+        persisted_user = await data_layer.create_user(test_user)
+        assert persisted_user
+
+        result = await data_layer.get_thread("test_thread")
+    assert result is None
+
+
+async def test_update_thread(
+    mock_chainlit_context, test_user: User, data_layer: SQLAlchemyDataLayer
+):
+    async with mock_chainlit_context:
+        persisted_user = await data_layer.create_user(test_user)
+        assert persisted_user
+
+        await data_layer.update_thread("test_thread", persisted_user.identifier)
+    assert True
+
+
+async def test_delete_thread(
+    mock_chainlit_context, test_user: User, data_layer: SQLAlchemyDataLayer
+):
+    async with mock_chainlit_context:
+        persisted_user = await data_layer.create_user(test_user)
+        assert persisted_user
+
+        await data_layer.update_thread("test_thread", "test_user")
+        await data_layer.delete_thread("test_thread")
+        thread = await data_layer.get_thread("test_thread")
+    assert thread is None
+    assert True

backend/tests/conftest.py

@@ -109,7 +109,6 @@ async def auth_func(
 
 async def test_on_message(mock_chainlit_context, test_config):
     from chainlit.callbacks import on_message
-    from chainlit.config import config
     from chainlit.message import Message
 
     async with mock_chainlit_context as context: