chore: import upstream snapshot with attribution

tests/api/user/test_conversations.py

@@ -0,0 +1,771 @@
+import uuid
+from contextlib import contextmanager
+from unittest.mock import patch
+
+import pytest
+from flask import Flask
+
+
+@pytest.fixture
+def app():
+    app = Flask(__name__)
+    return app
+
+
+@contextmanager
+def _patch_conversations_db(conn):
+    @contextmanager
+    def _yield_conn():
+        yield conn
+
+    with patch(
+        "application.api.user.conversations.routes.db_session", _yield_conn
+    ), patch(
+        "application.api.user.conversations.routes.db_readonly", _yield_conn
+    ):
+        yield
+
+
+def _seed_conversation(pg_conn, user_id, name="Test Conv"):
+    """Create a conversation and return its PG uuid id as str."""
+    from application.storage.db.repositories.conversations import (
+        ConversationsRepository,
+    )
+    repo = ConversationsRepository(pg_conn)
+    conv = repo.create(user_id, name=name)
+    return str(conv["id"])
+
+
+@pytest.mark.unit
+class TestDeleteConversation:
+    pass
+
+    def test_returns_401_unauthenticated(self, app):
+        from application.api.user.conversations.routes import DeleteConversation
+
+        with app.test_request_context("/api/delete_conversation?id=abc"):
+            from flask import request
+
+            request.decoded_token = None
+            response = DeleteConversation().post()
+
+        assert response.status_code == 401
+
+    def test_returns_400_missing_id(self, app):
+        from application.api.user.conversations.routes import DeleteConversation
+
+        with app.test_request_context("/api/delete_conversation"):
+            from flask import request
+
+            request.decoded_token = {"sub": "user1"}
+            response = DeleteConversation().post()
+
+        assert response.status_code == 400
+
+
+@pytest.mark.unit
+class TestDeleteAllConversations:
+    pass
+
+    def test_returns_401_unauthenticated(self, app):
+        from application.api.user.conversations.routes import DeleteAllConversations
+
+        with app.test_request_context("/api/delete_all_conversations"):
+            from flask import request
+
+            request.decoded_token = None
+            response = DeleteAllConversations().get()
+
+        assert response.status_code == 401
+
+
+@pytest.mark.unit
+class TestGetConversations:
+    pass
+
+    def test_returns_401_unauthenticated(self, app):
+        from application.api.user.conversations.routes import GetConversations
+
+        with app.test_request_context("/api/get_conversations"):
+            from flask import request
+
+            request.decoded_token = None
+            response = GetConversations().get()
+
+        assert response.status_code == 401
+
+
+@pytest.mark.unit
+class TestGetSingleConversation:
+    pass
+
+    def test_returns_400_missing_id(self, app):
+        from application.api.user.conversations.routes import GetSingleConversation
+
+        with app.test_request_context("/api/get_single_conversation"):
+            from flask import request
+
+            request.decoded_token = {"sub": "user1"}
+            response = GetSingleConversation().get()
+
+        assert response.status_code == 400
+
+
+
+@pytest.mark.unit
+class TestUpdateConversationName:
+    pass
+
+    def test_returns_400_missing_fields(self, app):
+        from application.api.user.conversations.routes import UpdateConversationName
+
+        with app.test_request_context(
+            "/api/update_conversation_name",
+            method="POST",
+            json={"id": str(uuid.uuid4().hex[:24])},
+        ):
+            from flask import request
+
+            request.decoded_token = {"sub": "user1"}
+            response = UpdateConversationName().post()
+
+        assert response.status_code == 400
+
+
+@pytest.mark.unit
+class TestSubmitFeedback:
+    pass
+
+    def test_returns_400_missing_fields(self, app):
+        from application.api.user.conversations.routes import SubmitFeedback
+
+        with app.test_request_context(
+            "/api/feedback",
+            method="POST",
+            json={"feedback": "LIKE"},
+        ):
+            from flask import request
+
+            request.decoded_token = {"sub": "user1"}
+            response = SubmitFeedback().post()
+
+        assert response.status_code == 400
+
+
+# ---------------------------------------------------------------------------
+# Happy-path tests exercising real PG via the ephemeral pg_conn fixture.
+# ---------------------------------------------------------------------------
+
+
+class TestDeleteConversationHappy:
+    def test_deletes_existing_conversation(self, app, pg_conn):
+        from application.api.user.conversations.routes import DeleteConversation
+        from application.storage.db.repositories.conversations import (
+            ConversationsRepository,
+        )
+
+        user = "user-del"
+        conv_id = _seed_conversation(pg_conn, user)
+
+        with _patch_conversations_db(pg_conn), app.test_request_context(
+            f"/api/delete_conversation?id={conv_id}"
+        ):
+            from flask import request
+
+            request.decoded_token = {"sub": user}
+            response = DeleteConversation().post()
+
+        assert response.status_code == 200
+        assert response.json["success"] is True
+        # Gone
+        assert ConversationsRepository(pg_conn).get_any(conv_id, user) is None
+
+    def test_delete_nonexistent_still_returns_200(self, app, pg_conn):
+        """get_any returns None, so delete is a no-op but endpoint succeeds."""
+        from application.api.user.conversations.routes import DeleteConversation
+
+        with _patch_conversations_db(pg_conn), app.test_request_context(
+            f"/api/delete_conversation?id={uuid.uuid4()}"
+        ):
+            from flask import request
+
+            request.decoded_token = {"sub": "u"}
+            response = DeleteConversation().post()
+
+        assert response.status_code == 200
+
+    def test_db_error_returns_400(self, app):
+        from application.api.user.conversations.routes import DeleteConversation
+
+        @contextmanager
+        def _broken():
+            raise RuntimeError("boom")
+            yield
+
+        with patch(
+            "application.api.user.conversations.routes.db_session", _broken
+        ), app.test_request_context("/api/delete_conversation?id=abc"):
+            from flask import request
+
+            request.decoded_token = {"sub": "u"}
+            response = DeleteConversation().post()
+
+        assert response.status_code == 400
+
+
+class TestDeleteAllConversationsHappy:
+    def test_deletes_all_conversations(self, app, pg_conn):
+        from application.api.user.conversations.routes import (
+            DeleteAllConversations,
+        )
+        from application.storage.db.repositories.conversations import (
+            ConversationsRepository,
+        )
+
+        user = "user-delall"
+        _seed_conversation(pg_conn, user, name="a")
+        _seed_conversation(pg_conn, user, name="b")
+
+        with _patch_conversations_db(pg_conn), app.test_request_context(
+            "/api/delete_all_conversations"
+        ):
+            from flask import request
+
+            request.decoded_token = {"sub": user}
+            response = DeleteAllConversations().get()
+
+        assert response.status_code == 200
+        assert ConversationsRepository(pg_conn).list_for_user(user) == []
+
+    def test_db_error_returns_400(self, app):
+        from application.api.user.conversations.routes import (
+            DeleteAllConversations,
+        )
+
+        @contextmanager
+        def _broken():
+            raise RuntimeError("boom")
+            yield
+
+        with patch(
+            "application.api.user.conversations.routes.db_session", _broken
+        ), app.test_request_context("/api/delete_all_conversations"):
+            from flask import request
+
+            request.decoded_token = {"sub": "u"}
+            response = DeleteAllConversations().get()
+
+        assert response.status_code == 400
+
+
+class TestGetConversationsHappy:
+    def test_returns_list_of_conversations(self, app, pg_conn):
+        from application.api.user.conversations.routes import GetConversations
+
+        user = "user-list"
+        c1 = _seed_conversation(pg_conn, user, name="one")
+        c2 = _seed_conversation(pg_conn, user, name="two")
+
+        with _patch_conversations_db(pg_conn), app.test_request_context(
+            "/api/get_conversations"
+        ):
+            from flask import request
+
+            request.decoded_token = {"sub": user}
+            response = GetConversations().get()
+
+        assert response.status_code == 200
+        ids = {c["id"] for c in response.json}
+        assert c1 in ids and c2 in ids
+        # agent_id, is_shared_usage, shared_token keys present
+        for c in response.json:
+            assert "agent_id" in c
+            assert "is_shared_usage" in c
+            assert "shared_token" in c
+
+    def test_db_error_returns_400(self, app):
+        from application.api.user.conversations.routes import GetConversations
+
+        @contextmanager
+        def _broken():
+            raise RuntimeError("boom")
+            yield
+
+        with patch(
+            "application.api.user.conversations.routes.db_readonly", _broken
+        ), app.test_request_context("/api/get_conversations"):
+            from flask import request
+
+            request.decoded_token = {"sub": "u"}
+            response = GetConversations().get()
+
+        assert response.status_code == 400
+
+
+class TestGetSingleConversationHappy:
+    def test_returns_401_unauthenticated(self, app):
+        from application.api.user.conversations.routes import (
+            GetSingleConversation,
+        )
+
+        with app.test_request_context("/api/get_single_conversation?id=x"):
+            from flask import request
+
+            request.decoded_token = None
+            response = GetSingleConversation().get()
+
+        assert response.status_code == 401
+
+    def test_returns_404_not_found(self, app, pg_conn):
+        from application.api.user.conversations.routes import (
+            GetSingleConversation,
+        )
+
+        with _patch_conversations_db(pg_conn), app.test_request_context(
+            f"/api/get_single_conversation?id={uuid.uuid4()}"
+        ):
+            from flask import request
+
+            request.decoded_token = {"sub": "u"}
+            response = GetSingleConversation().get()
+
+        assert response.status_code == 404
+
+    def test_returns_conversation_with_messages(self, app, pg_conn):
+        from application.api.user.conversations.routes import (
+            GetSingleConversation,
+        )
+        from application.storage.db.repositories.conversations import (
+            ConversationsRepository,
+        )
+
+        user = "user-get"
+        conv_id = _seed_conversation(pg_conn, user, name="chat")
+        # Append a message
+        ConversationsRepository(pg_conn).append_message(
+            conv_id,
+            {
+                "prompt": "hi",
+                "response": "hello",
+                "thought": None,
+                "sources": [],
+                "tool_calls": [],
+                "timestamp": None,
+                "model_id": None,
+            },
+        )
+
+        with _patch_conversations_db(pg_conn), app.test_request_context(
+            f"/api/get_single_conversation?id={conv_id}"
+        ):
+            from flask import request
+
+            request.decoded_token = {"sub": user}
+            response = GetSingleConversation().get()
+
+        assert response.status_code == 200
+        data = response.json
+        assert isinstance(data["queries"], list)
+        assert data["queries"][0]["prompt"] == "hi"
+        assert data["queries"][0]["response"] == "hello"
+
+    def test_returns_message_with_dict_feedback(self, app, pg_conn):
+        from application.api.user.conversations.routes import (
+            GetSingleConversation,
+        )
+        from application.storage.db.repositories.conversations import (
+            ConversationsRepository,
+        )
+
+        user = "user-fb"
+        conv_id = _seed_conversation(pg_conn, user, name="fb")
+        repo = ConversationsRepository(pg_conn)
+        repo.append_message(conv_id, {"prompt": "p", "response": "r"})
+        repo.set_feedback(
+            conv_id, 0, {"text": "like", "timestamp": "2024-01-01T00:00:00Z"}
+        )
+
+        with _patch_conversations_db(pg_conn), app.test_request_context(
+            f"/api/get_single_conversation?id={conv_id}"
+        ):
+            from flask import request
+
+            request.decoded_token = {"sub": user}
+            response = GetSingleConversation().get()
+
+        assert response.status_code == 200
+        q = response.json["queries"][0]
+        assert q["feedback"] == "like"
+        assert q["feedback_timestamp"] == "2024-01-01T00:00:00Z"
+
+    def test_db_error_returns_400(self, app):
+        from application.api.user.conversations.routes import (
+            GetSingleConversation,
+        )
+
+        @contextmanager
+        def _broken():
+            raise RuntimeError("boom")
+            yield
+
+        with patch(
+            "application.api.user.conversations.routes.db_readonly", _broken
+        ), app.test_request_context("/api/get_single_conversation?id=abc"):
+            from flask import request
+
+            request.decoded_token = {"sub": "u"}
+            response = GetSingleConversation().get()
+
+        assert response.status_code == 400
+
+
+@pytest.mark.unit
+class TestGetMessageTail:
+    """Tail-poll endpoint (``GET /api/messages/<id>/tail``) used by the
+    frontend to recover a placeholder/streaming row after a refresh.
+    """
+
+    def _seed_in_flight_message(self, pg_conn, owner_user_id):
+        from application.storage.db.repositories.conversations import (
+            ConversationsRepository,
+        )
+
+        conv_id = _seed_conversation(pg_conn, owner_user_id, name="streaming chat")
+        repo = ConversationsRepository(pg_conn)
+        msg = repo.reserve_message(
+            conv_id,
+            prompt="what's happening?",
+            placeholder_response=(
+                "Response was terminated prior to completion, try regenerating."
+            ),
+            request_id=str(uuid.uuid4()),
+            status="streaming",
+        )
+        return conv_id, str(msg["id"])
+
+    def test_owner_can_tail(self, app, pg_conn):
+        from application.api.user.conversations.routes import GetMessageTail
+
+        owner = "user-owner"
+        _, msg_id = self._seed_in_flight_message(pg_conn, owner)
+
+        with _patch_conversations_db(pg_conn), app.test_request_context(
+            f"/api/messages/{msg_id}/tail"
+        ):
+            from flask import request
+
+            request.decoded_token = {"sub": owner}
+            response = GetMessageTail().get(msg_id)
+
+        assert response.status_code == 200
+        assert response.json["status"] == "streaming"
+        assert response.json["message_id"] == msg_id
+
+    def test_shared_user_can_tail(self, app, pg_conn):
+        """A user in ``conversations.shared_with`` must be able to tail
+        an in-flight placeholder. Without the shared-with predicate
+        here, ``get_single_conversation`` lets them load the row but
+        the tail-poll silently 404s and the in-flight bubble never
+        resolves on the shared user's side.
+        """
+        from application.api.user.conversations.routes import GetMessageTail
+        from application.storage.db.repositories.conversations import (
+            ConversationsRepository,
+        )
+
+        owner = "user-owner-shared"
+        shared_user = "user-shared"
+        conv_id, msg_id = self._seed_in_flight_message(pg_conn, owner)
+        ConversationsRepository(pg_conn).add_shared_user(conv_id, shared_user)
+
+        with _patch_conversations_db(pg_conn), app.test_request_context(
+            f"/api/messages/{msg_id}/tail"
+        ):
+            from flask import request
+
+            request.decoded_token = {"sub": shared_user}
+            response = GetMessageTail().get(msg_id)
+
+        assert response.status_code == 200
+        assert response.json["message_id"] == msg_id
+
+    def test_non_member_gets_404(self, app, pg_conn):
+        from application.api.user.conversations.routes import GetMessageTail
+
+        owner = "user-owner-private"
+        intruder = "user-intruder"
+        _, msg_id = self._seed_in_flight_message(pg_conn, owner)
+
+        with _patch_conversations_db(pg_conn), app.test_request_context(
+            f"/api/messages/{msg_id}/tail"
+        ):
+            from flask import request
+
+            request.decoded_token = {"sub": intruder}
+            response = GetMessageTail().get(msg_id)
+
+        assert response.status_code == 404
+
+    def test_streaming_row_returns_partial_from_journal(self, app, pg_conn):
+        """Mid-stream rows must rebuild from message_events, not return the placeholder."""
+        from application.api.user.conversations.routes import GetMessageTail
+        from application.storage.db.repositories.message_events import (
+            MessageEventsRepository,
+        )
+
+        owner = "user-tail-partial"
+        _, msg_id = self._seed_in_flight_message(pg_conn, owner)
+        events_repo = MessageEventsRepository(pg_conn)
+        events_repo.record(msg_id, 0, "message_id", {"type": "message_id"})
+        events_repo.record(msg_id, 1, "answer", {"type": "answer", "answer": "Hello"})
+        events_repo.record(msg_id, 2, "answer", {"type": "answer", "answer": ", world"})
+        events_repo.record(
+            msg_id, 3, "source", {"type": "source", "source": [{"id": "s1"}]}
+        )
+
+        with _patch_conversations_db(pg_conn), app.test_request_context(
+            f"/api/messages/{msg_id}/tail"
+        ):
+            from flask import request
+
+            request.decoded_token = {"sub": owner}
+            response = GetMessageTail().get(msg_id)
+
+        assert response.status_code == 200
+        assert response.json["status"] == "streaming"
+        assert response.json["response"] == "Hello, world"
+        assert response.json["sources"] == [{"id": "s1"}]
+        assert "terminated prior to completion" not in (
+            response.json["response"] or ""
+        )
+
+    def test_streaming_row_with_empty_journal_returns_empty_response(
+        self, app, pg_conn
+    ):
+        """Empty journal returns empty response, not the placeholder."""
+        from application.api.user.conversations.routes import GetMessageTail
+
+        owner = "user-tail-empty"
+        _, msg_id = self._seed_in_flight_message(pg_conn, owner)
+
+        with _patch_conversations_db(pg_conn), app.test_request_context(
+            f"/api/messages/{msg_id}/tail"
+        ):
+            from flask import request
+
+            request.decoded_token = {"sub": owner}
+            response = GetMessageTail().get(msg_id)
+
+        assert response.status_code == 200
+        assert response.json["status"] == "streaming"
+        assert response.json["response"] == ""
+
+
+class TestUpdateConversationNameHappy:
+    def test_returns_401_unauthenticated(self, app):
+        from application.api.user.conversations.routes import (
+            UpdateConversationName,
+        )
+
+        with app.test_request_context(
+            "/api/update_conversation_name",
+            method="POST",
+            json={"id": "x", "name": "n"},
+        ):
+            from flask import request
+
+            request.decoded_token = None
+            response = UpdateConversationName().post()
+
+        assert response.status_code == 401
+
+    def test_renames_conversation(self, app, pg_conn):
+        from application.api.user.conversations.routes import (
+            UpdateConversationName,
+        )
+        from application.storage.db.repositories.conversations import (
+            ConversationsRepository,
+        )
+
+        user = "user-rename"
+        conv_id = _seed_conversation(pg_conn, user, name="old")
+
+        with _patch_conversations_db(pg_conn), app.test_request_context(
+            "/api/update_conversation_name",
+            method="POST",
+            json={"id": conv_id, "name": "new"},
+        ):
+            from flask import request
+
+            request.decoded_token = {"sub": user}
+            response = UpdateConversationName().post()
+
+        assert response.status_code == 200
+        got = ConversationsRepository(pg_conn).get_any(conv_id, user)
+        assert got["name"] == "new"
+
+    def test_rename_nonexistent_still_returns_200(self, app, pg_conn):
+        from application.api.user.conversations.routes import (
+            UpdateConversationName,
+        )
+
+        with _patch_conversations_db(pg_conn), app.test_request_context(
+            "/api/update_conversation_name",
+            method="POST",
+            json={"id": str(uuid.uuid4()), "name": "n"},
+        ):
+            from flask import request
+
+            request.decoded_token = {"sub": "u"}
+            response = UpdateConversationName().post()
+
+        assert response.status_code == 200
+
+    def test_db_error_returns_400(self, app):
+        from application.api.user.conversations.routes import (
+            UpdateConversationName,
+        )
+
+        @contextmanager
+        def _broken():
+            raise RuntimeError("boom")
+            yield
+
+        with patch(
+            "application.api.user.conversations.routes.db_session", _broken
+        ), app.test_request_context(
+            "/api/update_conversation_name",
+            method="POST",
+            json={"id": "x", "name": "n"},
+        ):
+            from flask import request
+
+            request.decoded_token = {"sub": "u"}
+            response = UpdateConversationName().post()
+
+        assert response.status_code == 400
+
+
+class TestSubmitFeedbackHappy:
+    def test_returns_401_unauthenticated(self, app):
+        from application.api.user.conversations.routes import SubmitFeedback
+
+        with app.test_request_context(
+            "/api/feedback",
+            method="POST",
+            json={
+                "feedback": "like",
+                "question_index": 0,
+                "conversation_id": "x",
+            },
+        ):
+            from flask import request
+
+            request.decoded_token = None
+            response = SubmitFeedback().post()
+
+        assert response.status_code == 401
+
+    def test_submits_feedback(self, app, pg_conn):
+        from application.api.user.conversations.routes import SubmitFeedback
+        from application.storage.db.repositories.conversations import (
+            ConversationsRepository,
+        )
+
+        user = "user-fb1"
+        conv_id = _seed_conversation(pg_conn, user, name="fb")
+        ConversationsRepository(pg_conn).append_message(
+            conv_id, {"prompt": "p", "response": "r"}
+        )
+
+        with _patch_conversations_db(pg_conn), app.test_request_context(
+            "/api/feedback",
+            method="POST",
+            json={
+                "feedback": "LIKE",  # uppercase normalized to lowercase
+                "question_index": 0,
+                "conversation_id": conv_id,
+            },
+        ):
+            from flask import request
+
+            request.decoded_token = {"sub": user}
+            response = SubmitFeedback().post()
+
+        assert response.status_code == 200
+        msgs = ConversationsRepository(pg_conn).get_messages(conv_id)
+        fb = msgs[0].get("feedback")
+        assert fb and fb.get("text") == "like"
+
+    def test_none_feedback_allowed(self, app, pg_conn):
+        from application.api.user.conversations.routes import SubmitFeedback
+        from application.storage.db.repositories.conversations import (
+            ConversationsRepository,
+        )
+
+        user = "user-fb-none"
+        conv_id = _seed_conversation(pg_conn, user)
+        ConversationsRepository(pg_conn).append_message(
+            conv_id, {"prompt": "p", "response": "r"}
+        )
+
+        with _patch_conversations_db(pg_conn), app.test_request_context(
+            "/api/feedback",
+            method="POST",
+            json={
+                "feedback": None,
+                "question_index": 0,
+                "conversation_id": conv_id,
+            },
+        ):
+            from flask import request
+
+            request.decoded_token = {"sub": user}
+            response = SubmitFeedback().post()
+
+        assert response.status_code == 200
+
+    def test_returns_404_for_missing_conversation(self, app, pg_conn):
+        from application.api.user.conversations.routes import SubmitFeedback
+
+        with _patch_conversations_db(pg_conn), app.test_request_context(
+            "/api/feedback",
+            method="POST",
+            json={
+                "feedback": "like",
+                "question_index": 0,
+                "conversation_id": str(uuid.uuid4()),
+            },
+        ):
+            from flask import request
+
+            request.decoded_token = {"sub": "u"}
+            response = SubmitFeedback().post()
+
+        assert response.status_code == 404
+
+    def test_db_error_returns_400(self, app):
+        from application.api.user.conversations.routes import SubmitFeedback
+
+        @contextmanager
+        def _broken():
+            raise RuntimeError("boom")
+            yield
+
+        with patch(
+            "application.api.user.conversations.routes.db_session", _broken
+        ), app.test_request_context(
+            "/api/feedback",
+            method="POST",
+            json={
+                "feedback": "like",
+                "question_index": 0,
+                "conversation_id": "x",
+            },
+        ):
+            from flask import request
+
+            request.decoded_token = {"sub": "u"}
+            response = SubmitFeedback().post()
+
+        assert response.status_code == 400