mirror of
http://88.130.71.182:3000/BlitTech/contexta_be.git
synced 2026-06-12 23:23:21 +00:00
308 lines
13 KiB
Python
308 lines
13 KiB
Python
"""Tests for chat endpoints."""
|
|
import pytest
|
|
from unittest.mock import MagicMock, patch, AsyncMock
|
|
|
|
AUTH = {"Authorization": "Bearer test-token"}
|
|
|
|
|
|
def _make_chatbot(published=True, collection="col-1", **kwargs):
|
|
base = {
|
|
"id": "cb-1",
|
|
"name": "Test Bot",
|
|
"is_published": published,
|
|
"qdrant_collection_name": collection,
|
|
"company_id": "company-1",
|
|
"handoff_enabled": False,
|
|
"handoff_keywords": [],
|
|
"lead_capture_enabled": False,
|
|
"lead_capture_trigger": None,
|
|
"booking_enabled": False,
|
|
"system_prompt": "You are helpful.",
|
|
"welcome_message": "Hello!",
|
|
"companies": {"name": "Acme", "logo_url": None},
|
|
}
|
|
base.update(kwargs)
|
|
return base
|
|
|
|
|
|
def _make_chat_sb(chatbot=None, existing_conv=None, insert_conv=None):
|
|
"""Build a chainable supabase mock for chat tests."""
|
|
sb = MagicMock()
|
|
|
|
chatbot_data = [chatbot] if chatbot is not None else [_make_chatbot()]
|
|
conversation_insert = insert_conv or {"id": "conv-1", "session_id": "sess-1",
|
|
"status": "open", "message_count": 0}
|
|
|
|
call_counts = {}
|
|
|
|
def table_side(name):
|
|
m = MagicMock()
|
|
m.select.return_value = m
|
|
m.insert.return_value = m
|
|
m.update.return_value = m
|
|
m.delete.return_value = m
|
|
m.eq.return_value = m
|
|
m.in_.return_value = m
|
|
m.limit.return_value = m
|
|
m.order.return_value = m
|
|
m.range.return_value = m
|
|
m.gte.return_value = m
|
|
m.lt.return_value = m
|
|
|
|
if name == "chatbots":
|
|
m.execute.return_value = MagicMock(data=chatbot_data)
|
|
elif name == "conversations":
|
|
if existing_conv is not None:
|
|
m.execute.return_value = MagicMock(data=existing_conv, count=len(existing_conv))
|
|
else:
|
|
call_counts.setdefault("conversations", 0)
|
|
original_execute = m.execute
|
|
|
|
def conv_execute():
|
|
call_counts["conversations"] += 1
|
|
if call_counts["conversations"] == 1:
|
|
return MagicMock(data=[], count=0)
|
|
return MagicMock(data=[conversation_insert], count=1)
|
|
|
|
m.execute.side_effect = conv_execute
|
|
elif name == "messages":
|
|
m.execute.return_value = MagicMock(data=[], count=0)
|
|
elif name == "companies":
|
|
m.execute.return_value = MagicMock(data=[{"id": "company-1", "owner_id": "owner-1"}])
|
|
elif name == "subscriptions":
|
|
m.execute.return_value = MagicMock(data=[{"plan": "starter"}])
|
|
else:
|
|
m.execute.return_value = MagicMock(data=[], count=0)
|
|
return m
|
|
|
|
sb.table.side_effect = table_side
|
|
sb.auth = MagicMock()
|
|
return sb
|
|
|
|
|
|
class TestChatAuth:
|
|
def test_chat_does_not_require_auth_for_published_bot(self, client):
|
|
"""Public chat endpoint should work without auth for published bots."""
|
|
rag_result = {
|
|
"response": "Hello!",
|
|
"sources": [],
|
|
"model": "gpt-4",
|
|
"tokens_used": 10,
|
|
}
|
|
with patch("app.routers.chat.get_supabase") as mock_sb, \
|
|
patch("app.routers.chat.rag_engine") as mock_rag:
|
|
mock_rag.process_query = AsyncMock(return_value=rag_result)
|
|
mock_sb.return_value = _make_chat_sb()
|
|
resp = client.post("/api/v1/chat/cb-1", json={"message": "Hi", "language": "en"})
|
|
assert resp.status_code == 200
|
|
|
|
def test_chat_unpublished_bot_requires_auth(self, client):
|
|
unpublished = _make_chatbot(published=False)
|
|
with patch("app.routers.chat.get_supabase") as mock_sb:
|
|
mock_sb.return_value = _make_chat_sb(chatbot=unpublished)
|
|
resp = client.post("/api/v1/chat/cb-1", json={"message": "Hi", "language": "en"})
|
|
assert resp.status_code == 403
|
|
|
|
def test_chat_returns_404_when_chatbot_missing(self, client):
|
|
def table_side(name):
|
|
m = MagicMock()
|
|
m.select.return_value = m
|
|
m.eq.return_value = m
|
|
m.execute.return_value = MagicMock(data=[])
|
|
return m
|
|
|
|
sb = MagicMock()
|
|
sb.table.side_effect = table_side
|
|
sb.auth = MagicMock()
|
|
|
|
with patch("app.routers.chat.get_supabase", return_value=sb):
|
|
resp = client.post("/api/v1/chat/no-such-bot", json={"message": "Hi", "language": "en"})
|
|
assert resp.status_code == 404
|
|
|
|
|
|
class TestChatRateLimiting:
|
|
def test_rate_limit_429_after_30_requests(self, client):
|
|
"""After 30 requests from same IP, should return 429."""
|
|
from app.routers.chat import _rate_store
|
|
import time
|
|
_rate_store["testclient"] = [time.time() for _ in range(30)]
|
|
|
|
try:
|
|
rag_result = {"response": "Hi", "sources": [], "model": "m", "tokens_used": 0}
|
|
with patch("app.routers.chat.get_supabase") as mock_sb, \
|
|
patch("app.routers.chat.rag_engine") as mock_rag:
|
|
mock_rag.process_query = AsyncMock(return_value=rag_result)
|
|
mock_sb.return_value = _make_chat_sb()
|
|
resp = client.post("/api/v1/chat/cb-1", json={"message": "Hi", "language": "en"})
|
|
finally:
|
|
_rate_store.pop("testclient", None)
|
|
|
|
assert resp.status_code == 429
|
|
|
|
|
|
class TestChatResponse:
|
|
def _do_chat(self, client, rag_result, chatbot=None, message="Hello"):
|
|
with patch("app.routers.chat.get_supabase") as mock_sb, \
|
|
patch("app.routers.chat.rag_engine") as mock_rag:
|
|
mock_rag.process_query = AsyncMock(return_value=rag_result)
|
|
mock_sb.return_value = _make_chat_sb(chatbot=chatbot)
|
|
return client.post("/api/v1/chat/cb-1", json={"message": message, "language": "en"})
|
|
|
|
def test_response_shape(self, client):
|
|
rag_result = {"response": "Hello!", "sources": [], "model": "gpt-4", "tokens_used": 15}
|
|
resp = self._do_chat(client, rag_result)
|
|
assert resp.status_code == 200
|
|
body = resp.json()
|
|
assert "response" in body
|
|
assert "session_id" in body
|
|
assert "sources" in body
|
|
assert "model_used" in body
|
|
assert "tokens_used" in body
|
|
assert "needs_lead_capture" in body
|
|
assert "handoff" in body
|
|
|
|
def test_response_contains_rag_text(self, client):
|
|
rag_result = {"response": "42 is the answer", "sources": [], "model": "m", "tokens_used": 5}
|
|
resp = self._do_chat(client, rag_result)
|
|
assert resp.json()["response"] == "42 is the answer"
|
|
|
|
def test_chatbot_with_no_collection_returns_400(self, client):
|
|
no_collection_bot = _make_chatbot(collection=None)
|
|
rag_result = {"response": "", "sources": [], "model": "", "tokens_used": 0}
|
|
resp = self._do_chat(client, rag_result, chatbot=no_collection_bot)
|
|
assert resp.status_code == 400
|
|
assert "knowledge base" in resp.json()["detail"].lower()
|
|
|
|
def test_agent_handling_status_returns_empty_response(self, client):
|
|
chatbot = _make_chatbot()
|
|
conv_with_agent = [{"id": "conv-1", "session_id": "sess-1", "status": "agent_handling",
|
|
"message_count": 5, "language": "en", "user_id": None}]
|
|
rag_result = {"response": "Should not be reached", "sources": [], "model": "", "tokens_used": 0}
|
|
|
|
with patch("app.routers.chat.get_supabase") as mock_sb, \
|
|
patch("app.routers.chat.rag_engine") as mock_rag:
|
|
mock_rag.process_query = AsyncMock(return_value=rag_result)
|
|
mock_sb.return_value = _make_chat_sb(chatbot=chatbot, existing_conv=conv_with_agent)
|
|
resp = client.post("/api/v1/chat/cb-1",
|
|
json={"message": "Hi", "language": "en", "session_id": "sess-1"})
|
|
|
|
assert resp.status_code == 200
|
|
assert resp.json()["response"] == ""
|
|
|
|
|
|
class TestChatHandoff:
|
|
def test_handoff_triggered_by_keyword(self, client):
|
|
chatbot = _make_chatbot(handoff_enabled=True, handoff_keywords=["human", "agent"],
|
|
handoff_email="owner@test.com")
|
|
rag_result = {"response": "Connecting you...", "sources": [], "model": "m", "tokens_used": 5}
|
|
|
|
with patch("app.routers.chat.get_supabase") as mock_sb, \
|
|
patch("app.routers.chat.rag_engine") as mock_rag, \
|
|
patch("app.routers.chat.send_handoff_notification", new_callable=AsyncMock, create=True):
|
|
mock_rag.process_query = AsyncMock(return_value=rag_result)
|
|
mock_sb.return_value = _make_chat_sb(chatbot=chatbot)
|
|
resp = client.post("/api/v1/chat/cb-1", json={"message": "I need a human agent", "language": "en"})
|
|
|
|
assert resp.status_code == 200
|
|
assert resp.json()["handoff"] is True
|
|
|
|
def test_handoff_not_triggered_when_high_confidence_no_keyword(self, client):
|
|
# High confidence + no keyword match → no handoff
|
|
chatbot = _make_chatbot(handoff_enabled=True, handoff_keywords=["human"])
|
|
rag_result = {"response": "We open at 9am.", "sources": [], "confidence_score": 0.85,
|
|
"model": "m", "tokens_used": 5}
|
|
|
|
with patch("app.routers.chat.get_supabase") as mock_sb, \
|
|
patch("app.routers.chat.rag_engine") as mock_rag:
|
|
mock_rag.process_query = AsyncMock(return_value=rag_result)
|
|
mock_sb.return_value = _make_chat_sb(chatbot=chatbot)
|
|
resp = client.post("/api/v1/chat/cb-1", json={"message": "What are your hours?", "language": "en"})
|
|
|
|
assert resp.status_code == 200
|
|
assert resp.json()["handoff"] is False
|
|
|
|
def test_handoff_triggered_by_low_confidence(self, client):
|
|
# Low confidence (no sources) triggers handoff even without a keyword
|
|
chatbot = _make_chatbot(handoff_enabled=True, handoff_keywords=["human"])
|
|
rag_result = {"response": "I'm not sure.", "sources": [], "confidence_score": 0.1,
|
|
"model": "m", "tokens_used": 5}
|
|
|
|
with patch("app.routers.chat.get_supabase") as mock_sb, \
|
|
patch("app.routers.chat.rag_engine") as mock_rag:
|
|
mock_rag.process_query = AsyncMock(return_value=rag_result)
|
|
mock_sb.return_value = _make_chat_sb(chatbot=chatbot)
|
|
resp = client.post("/api/v1/chat/cb-1", json={"message": "Tell me about quantum physics", "language": "en"})
|
|
|
|
assert resp.status_code == 200
|
|
assert resp.json()["handoff"] is True
|
|
assert resp.json()["low_confidence"] is True
|
|
|
|
|
|
class TestChatHistory:
|
|
def test_history_returns_empty_for_unknown_session(self, client):
|
|
def table_side(name):
|
|
m = MagicMock()
|
|
m.select.return_value = m
|
|
m.eq.return_value = m
|
|
m.order.return_value = m
|
|
m.execute.return_value = MagicMock(data=[])
|
|
return m
|
|
|
|
sb = MagicMock()
|
|
sb.table.side_effect = table_side
|
|
sb.auth = MagicMock()
|
|
|
|
with patch("app.routers.chat.get_supabase", return_value=sb):
|
|
resp = client.get("/api/v1/chat/cb-1/history/no-such-session")
|
|
assert resp.status_code == 200
|
|
assert resp.json() == []
|
|
|
|
|
|
class TestChatFeedback:
|
|
def test_feedback_valid_positive(self, client):
|
|
def table_side(name):
|
|
m = MagicMock()
|
|
m.select.return_value = m
|
|
m.insert.return_value = m
|
|
m.eq.return_value = m
|
|
m.execute.return_value = MagicMock(data=[{"id": "msg-1", "conversation_id": "conv-1"}])
|
|
return m
|
|
|
|
sb = MagicMock()
|
|
sb.table.side_effect = table_side
|
|
sb.auth = MagicMock()
|
|
|
|
with patch("app.routers.chat.get_supabase", return_value=sb):
|
|
resp = client.post(
|
|
"/api/v1/chat/cb-1/feedback",
|
|
json={"message_id": "msg-1", "feedback": "positive"},
|
|
)
|
|
assert resp.status_code == 200
|
|
assert resp.json()["success"] is True
|
|
|
|
def test_feedback_invalid_value_rejected(self, client):
|
|
resp = client.post(
|
|
"/api/v1/chat/cb-1/feedback",
|
|
json={"message_id": "msg-1", "feedback": "meh"},
|
|
)
|
|
assert resp.status_code == 400
|
|
|
|
def test_feedback_message_not_found(self, client):
|
|
def table_side(name):
|
|
m = MagicMock()
|
|
m.select.return_value = m
|
|
m.eq.return_value = m
|
|
m.execute.return_value = MagicMock(data=[])
|
|
return m
|
|
|
|
sb = MagicMock()
|
|
sb.table.side_effect = table_side
|
|
sb.auth = MagicMock()
|
|
|
|
with patch("app.routers.chat.get_supabase", return_value=sb):
|
|
resp = client.post(
|
|
"/api/v1/chat/cb-1/feedback",
|
|
json={"message_id": "no-such-msg", "feedback": "negative"},
|
|
)
|
|
assert resp.status_code == 404
|