rag-backend-api / test_api.py
seraj-b2
graph rag added
d3f7d23
Raw History Blame Contribute Delete
14.4 kB
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__]))