Spaces:
Runtime error
Runtime error
File size: 14,425 Bytes
73ddeba d3f7d23 73ddeba 02cda1b 9c8bf34 d3f7d23 9c8bf34 d3f7d23 73ddeba 02cda1b | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 | import os
import pytest
from fastapi.testclient import TestClient
# Set environment variables for testing before importing main
os.environ["QDRANT_COLLECTION"] = "test_rag_documents"
# Ensure we run in memory during tests by clearing cloud credentials if any exist in env
if "QDRANT_URL" in os.environ:
del os.environ["QDRANT_URL"]
if "QDRANT_API_KEY" in os.environ:
del os.environ["QDRANT_API_KEY"]
from unittest.mock import MagicMock, patch
# Create a mock graph store globally for testing
mock_graph_store = MagicMock()
mock_graph_store.is_connected = True
mock_graph_store.get_status.return_value = {
"connection_type": "Mock Neo4j",
"status": "online",
"nodes_count": 5,
"relationships_count": 4
}
mock_graph_store.query_subgraph.return_value = "(Alice) -[WORKS_AT]-> (BobCorp)"
mock_graph_store.clear.return_value = True
with patch("graph_store.Neo4jGraphStore", return_value=mock_graph_store):
from main import app
# Mock Gemini extraction functions globally for test stability
from agent import GraphExtractionModel, EntityModel, RelationshipModel
mock_extraction_result = GraphExtractionModel(
entities=[
EntityModel(name="Alice", type="Person", description="A software engineer."),
EntityModel(name="BobCorp", type="Organization", description="A software company.")
],
relationships=[
RelationshipModel(source="Alice", target="BobCorp", type="WORKS_AT", description="works at")
]
)
patcher_extract_graph = patch("main.extract_graph_elements", return_value=mock_extraction_result)
patcher_extract_graph.start()
patcher_extract_entities = patch("main.extract_query_entities", return_value=["Alice", "BobCorp"])
patcher_extract_entities.start()
client = TestClient(app)
def test_root_endpoint():
response = client.get("/")
assert response.status_code == 200
data = response.json()
assert data["app"] == "RAG Backend Service"
assert data["status"] == "online"
def test_health_endpoint():
response = client.get("/health")
assert response.status_code == 200
data = response.json()
assert data["status"] == "healthy"
assert "vector_store" in data
assert data["vector_store"]["connection_type"] == "In-Memory (Local)"
def test_rag_pipeline_flow():
# 1. Clear database before starting
client.delete("/documents")
# Check stats are empty
status_response = client.get("/documents")
assert status_response.status_code == 200
assert status_response.json()["vectors_count"] == 0
# 2. Ingest documents
payload = {
"documents": [
{
"text": "Antigravity is a concept of creating a place or object that is free from the force of gravity. It does not refer to the lack of weight under gravity experienced in free fall.",
"metadata": {"source": "physics_101", "category": "gravity"}
},
{
"text": "Photosynthesis is the process used by plants, algae and certain bacteria to harness energy from sunlight and turn it into chemical energy.",
"metadata": {"source": "biology_101", "category": "plants"}
}
],
"chunk_size": 100,
"chunk_overlap": 10
}
ingest_response = client.post("/documents", json=payload)
assert ingest_response.status_code == 201
ingest_data = ingest_response.json()
assert ingest_data["status"] == "success"
assert ingest_data["documents_processed"] == 2
assert ingest_data["chunks_created"] > 0
# 3. Verify statistics updated
status_response = client.get("/documents")
assert status_response.json()["vectors_count"] == ingest_data["chunks_created"]
# 4. Search retrieval for gravity topic
retrieve_payload = {
"query": "How does antigravity work or what is it?",
"top_k": 2
}
retrieve_response = client.post("/retrieve", json=retrieve_payload)
assert retrieve_response.status_code == 200
retrieve_data = retrieve_response.json()
assert retrieve_data["query"] == retrieve_payload["query"]
assert len(retrieve_data["results"]) > 0
assert len(retrieve_data["context"]) > 0
# First result should match the antigravity text (higher similarity score)
assert "Antigravity" in retrieve_data["results"][0]["text"]
assert retrieve_data["results"][0]["metadata"]["category"] == "gravity"
# 5. Search retrieval for photosynthesis
retrieve_payload_bio = {
"query": "How do plants harness energy from sunlight?",
"top_k": 1
}
retrieve_response_bio = client.post("/retrieve", json=retrieve_payload_bio)
assert retrieve_response_bio.status_code == 200
retrieve_data_bio = retrieve_response_bio.json()
assert "Photosynthesis" in retrieve_data_bio["results"][0]["text"]
assert retrieve_data_bio["results"][0]["metadata"]["category"] == "plants"
# 6. Clear database
clear_response = client.delete("/documents")
assert clear_response.status_code == 200
assert clear_response.json()["status"] == "success"
# Check stats are empty again
status_response = client.get("/documents")
assert status_response.json()["vectors_count"] == 0
def test_upload_text_document():
# 1. Clear database before starting
client.delete("/documents")
# 2. Upload a txt file
dummy_text_data = "This is raw text content about photosynthesis from an uploaded text file."
response = client.post(
"/documents/upload",
files={"file": ("test.txt", dummy_text_data.encode("utf-8"), "text/plain")},
data={"chunk_size": 100, "chunk_overlap": 10, "metadata": '{"category": "test_txt"}'}
)
assert response.status_code == 201
data = response.json()
assert data["status"] == "success"
assert data["documents_processed"] == 1
assert data["chunks_created"] > 0
# Verify retrieval
retrieve_response = client.post("/retrieve", json={"query": "photosynthesis", "top_k": 1})
assert retrieve_response.status_code == 200
retrieve_data = retrieve_response.json()
assert len(retrieve_data["results"]) > 0
assert "photosynthesis" in retrieve_data["results"][0]["text"]
assert retrieve_data["results"][0]["metadata"]["source"] == "test.txt"
assert retrieve_data["results"][0]["metadata"]["category"] == "test_txt"
from unittest.mock import MagicMock, patch
def test_upload_pdf_document():
# 1. Clear database before starting
client.delete("/documents")
# 2. Mock PdfReader to return a dummy page with text
mock_page = MagicMock()
mock_page.extract_text.return_value = "This is text extracted from a mock PDF file about gravity."
mock_reader = MagicMock()
mock_reader.pages = [mock_page]
with patch("main.PdfReader", return_value=mock_reader) as mock_pdf_reader:
# Create a dummy PDF byte stream
dummy_pdf_data = b"%PDF-1.4 dummy content"
response = client.post(
"/documents/upload",
files={"file": ("test.pdf", dummy_pdf_data, "application/pdf")},
data={"chunk_size": 100, "chunk_overlap": 10, "metadata": '{"category": "test_pdf"}'}
)
assert response.status_code == 201
data = response.json()
assert data["status"] == "success"
assert data["documents_processed"] == 1
assert data["chunks_created"] > 0
# Verify PdfReader was initialized with the file bytes
mock_pdf_reader.assert_called_once()
called_args, _ = mock_pdf_reader.call_args
assert called_args[0].getvalue() == dummy_pdf_data
# Verify retrieval
retrieve_response = client.post("/retrieve", json={"query": "gravity", "top_k": 1})
assert retrieve_response.status_code == 200
retrieve_data = retrieve_response.json()
assert len(retrieve_data["results"]) > 0
assert "gravity" in retrieve_data["results"][0]["text"]
assert retrieve_data["results"][0]["metadata"]["source"] == "test.pdf"
assert retrieve_data["results"][0]["metadata"]["category"] == "test_pdf"
def test_upload_invalid_file_type():
response = client.post(
"/documents/upload",
files={"file": ("test.png", b"fake png bytes", "image/png")},
data={"chunk_size": 100, "chunk_overlap": 10}
)
assert response.status_code == 400
assert "Unsupported file format" in response.json()["detail"]
def test_upload_invalid_metadata():
response = client.post(
"/documents/upload",
files={"file": ("test.txt", b"some text", "text/plain")},
data={"metadata": "{invalid json}"}
)
assert response.status_code == 400
assert "valid JSON" in response.json()["detail"]
def test_upload_invalid_parameters():
# Invalid chunk_size
response = client.post(
"/documents/upload",
files={"file": ("test.txt", b"some text", "text/plain")},
data={"chunk_size": 10} # Below 50 limit
)
assert response.status_code == 400
assert "chunk_size must be between" in response.json()["detail"]
def test_agent_chat_endpoint_missing_api_key():
# Ensure GEMINI_API_KEY is not in env
with patch.dict(os.environ, {}, clear=True):
# Keep QDRANT_COLLECTION so the app can start/connect to memory db
with patch.dict(os.environ, {"QDRANT_COLLECTION": "test_rag_documents"}):
response = client.post("/agent/chat", json={"prompt": "hello"})
assert response.status_code == 500
assert "GEMINI_API_KEY environment variable is not set" in response.json()["detail"]
def test_agent_chat_endpoint_success():
mock_result = {
"answer": "This is a mock answer about antigravity.",
"tool_calls": [
{
"query": "antigravity",
"top_k": 3,
"results_count": 1,
"results": [
{
"text": "Antigravity is a concept...",
"score": 0.9,
"metadata": {"source": "physics_101"}
}
]
}
],
"sources": [
{
"text": "Antigravity is a concept...",
"score": 0.9,
"metadata": {"source": "physics_101"}
}
]
}
with patch("main.run_agent_rag", return_value=mock_result) as mock_run:
with patch.dict(os.environ, {"GEMINI_API_KEY": "mock-key"}):
response = client.post(
"/agent/chat",
json={
"prompt": "explain antigravity",
"chat_history": [
{"role": "user", "content": "hi"},
{"role": "model", "content": "hello"}
]
}
)
assert response.status_code == 200
data = response.json()
assert data["answer"] == "This is a mock answer about antigravity."
assert len(data["tool_calls"]) == 1
assert data["tool_calls"][0]["query"] == "antigravity"
assert len(data["sources"]) == 1
assert data["sources"][0]["metadata"]["source"] == "physics_101"
# Verify mock was called with correct parameters
mock_run.assert_called_once()
called_args, called_kwargs = mock_run.call_args
assert called_kwargs["user_message"] == "explain antigravity"
assert called_kwargs["graph_store"] == mock_graph_store
assert called_kwargs["chat_history"] == [
{"role": "user", "content": "hi"},
{"role": "model", "content": "hello"}
]
def test_health_endpoint_includes_graph():
response = client.get("/health")
assert response.status_code == 200
data = response.json()
assert "graph_store" in data
assert data["graph_store"]["connection_type"] == "Mock Neo4j"
assert data["graph_store"]["status"] == "online"
def test_documents_ingest_calls_graph_store():
mock_graph_store.reset_mock()
# Ingest document
payload = {
"documents": [
{
"text": "Alice works at BobCorp.",
"metadata": {"source": "test_doc"}
}
],
"chunk_size": 100,
"chunk_overlap": 10
}
response = client.post("/documents", json=payload)
assert response.status_code == 201
# Verify graph store add_graph_data was called
mock_graph_store.add_graph_data.assert_called_once()
called_args, called_kwargs = mock_graph_store.add_graph_data.call_args
assert called_kwargs["source"] == "test_doc"
assert called_kwargs["chunk_text"] == "Alice works at BobCorp."
assert called_kwargs["entities"][0]["name"] == "Alice"
assert called_kwargs["relationships"][0]["type"] == "WORKS_AT"
def test_retrieve_graph_endpoint():
response = client.post(
"/retrieve/graph",
json={"query": "Alice BobCorp", "top_k_entities": 2}
)
assert response.status_code == 200
data = response.json()
assert data["query"] == "Alice BobCorp"
assert data["extracted_entities"] == ["Alice", "BobCorp"]
assert "WORKS_AT" in data["relationships"]
def test_query_graph_endpoint():
mock_genai_client = MagicMock()
mock_response = MagicMock()
mock_response.text = "Based on the graph, Alice works at BobCorp."
mock_genai_client.models.generate_content.return_value = mock_response
with patch("google.genai.Client", return_value=mock_genai_client):
with patch.dict(os.environ, {"GEMINI_API_KEY": "mock-key"}):
response = client.post(
"/query/graph",
json={"query": "Where does Alice work?"}
)
assert response.status_code == 200
data = response.json()
assert data["query"] == "Where does Alice work?"
assert "Alice works at BobCorp" in data["answer"]
assert "WORKS_AT" in data["context"]
def test_clear_documents_clears_graph():
mock_graph_store.reset_mock()
response = client.delete("/documents")
assert response.status_code == 200
mock_graph_store.clear.assert_called_once()
if __name__ == "__main__":
import sys
import pytest
sys.exit(pytest.main([__file__]))
|