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__]))